diff --git a/.github/workflows/bench-lsp.yml b/.github/workflows/bench-lsp.yml
deleted file mode 100644
index 64b2d46e9bc..00000000000
--- a/.github/workflows/bench-lsp.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: Benchmark LSP
-
-on:
-  pull_request:
-    draft: false
-    paths:
-      - forc-plugins/forc-lsp/**
-      - sway-lsp/**
-      - forc-pkg/**
-      - sway-core/**
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  compare-master:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: Swatinem/rust-cache@v2
-      - uses: actions/checkout@v3
-      - uses: boa-dev/criterion-compare-action@v3.2.4
-        with:
-          cwd: "./sway-lsp"
-          branchName: ${{ github.base_ref }}
-          token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
new file mode 100644
index 00000000000..7f5389b81c0
--- /dev/null
+++ b/.github/workflows/benchmark.yml
@@ -0,0 +1,41 @@
+name: Codspeed Benchmarks
+
+on:
+  push:
+    branches:
+      - "master"
+  pull_request:
+    paths: 
+       - forc-plugins/forc-lsp/** 
+       - sway-lsp/** 
+       - forc-pkg/** 
+       - sway-core/**
+  # `workflow_dispatch` allows CodSpeed to trigger backtest
+  # performance analysis in order to generate initial data.
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup rust toolchain, cache and cargo-codspeed binary
+        uses: moonrepo/setup-rust@v0
+        with:
+          channel: stable
+          cache-target: release
+          bins: cargo-codspeed
+
+      - name: Build the benchmark target(s)
+        run: cargo codspeed build
+
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@v3
+        with:
+          run: cargo codspeed run
+          token: ${{ secrets.CODSPEED_TOKEN }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4c1995aff32..58be69c8e88 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,12 +15,12 @@ concurrency:
 env:
   CARGO_TERM_COLOR: always
   REGISTRY: ghcr.io
-  RUST_VERSION: 1.76.0
-  NIGHTLY_RUST_VERSION: nightly-2024-02-07
+  RUST_VERSION: 1.79.0
+  NIGHTLY_RUST_VERSION: nightly-2024-07-16
 
 jobs:
   get-fuel-core-version:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     outputs:
       fuel_core_version: ${{steps.get_fuel_core_ver.outputs.version}}
     steps:
@@ -40,7 +40,7 @@ jobs:
           echo "version=$version" >> "$GITHUB_OUTPUT"
 
   build-sway-lib-core:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -48,13 +48,15 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
       - name: Build sway-lib-core
         run: forc build --path sway-lib-core
 
   build-sway-lib-std:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -62,13 +64,15 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
       - name: Build sway-lib-std
         run: forc build --path sway-lib-std
 
   build-sway-examples:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -76,11 +80,13 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Build Sway examples workspace
         run: cargo run --locked -p forc -- build --locked --path ./examples/Forc.toml
 
   build-reference-examples:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -88,11 +94,13 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Build Sway examples workspace
         run: cargo run --locked -p forc -- build --locked --path ./docs/reference/src/code/Forc.toml
 
   forc-fmt-check-sway-lib-core:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -100,11 +108,13 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Check Sway sway-lib-core formatting
         run: cargo run --locked -p forc-fmt -- --check --path ./sway-lib-core
 
   forc-fmt-check-sway-lib-std:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -112,11 +122,13 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Check Sway sway-lib-std formatting
         run: cargo run --locked -p forc-fmt -- --check --path ./sway-lib-std
 
   forc-fmt-check-sway-examples:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -124,11 +136,13 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Check Sway examples formatting
         run: cargo run --locked -p forc-fmt -- --check --path ./examples
 
   forc-fmt-check-panic:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -136,17 +150,19 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install forc-fmt
         run: cargo install --locked --debug --path ./forc-plugins/forc-fmt
       - name: Run the formatter against all sway projects and fail if any of them panic
         run: scripts/formatter/forc-fmt-check-panic.sh
 
   check-sdk-harness-test-suite-compatibility:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - name: Checkout code
         uses: actions/checkout@v2
-      
+
       - name: Set up Rust
         uses: actions-rs/toolchain@v1
         with:
@@ -194,7 +210,7 @@ jobs:
       - name: Run mdbook build
         uses: peaceiris/actions-mdbook@v1
         with:
-          mdbook-version: '0.4.25'
+          mdbook-version: "0.4.25"
       - name: Emit book logs to tmp.txt, fail if build logs contain 'ERROR'
         run: |
           MDBOOK_preprocessor__FORC_documenter__STRICT="true" mdbook build docs/book 2>&1 | tee tmp.txt
@@ -219,7 +235,7 @@ jobs:
           fi
 
   build-forc-doc-sway-lib-std:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -227,6 +243,8 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
       - name: Install Forc plugins
@@ -236,14 +254,17 @@ jobs:
         run: forc doc --manifest-path ./sway-lib-std
 
   build-forc-test-project:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_VERSION }}
+          targets: wasm32-unknown-unknown
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
       - name: Initialize test project
@@ -257,6 +278,8 @@ jobs:
       #   run: (cd test-proj && forc test)
       - name: Install cargo-generate
         run: cargo install --locked cargo-generate
+      - name: Install fuel-core
+        run: cargo install --locked fuel-core-bin
       - name: Generate Rust Integration Tests
         run: (cd test-proj && cargo generate --init --path ../templates/sway-test-rs --name test-proj)
       - name: Update project cargo manifest with workspace
@@ -268,7 +291,7 @@ jobs:
         run: (cd test-proj && cargo test --release)
 
   cargo-build-workspace:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-8vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -276,13 +299,15 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
-      - name: 'Build Workspace'
+        with:
+          cache-provider: "buildjet"
+      - name: "Build Workspace"
         run: cargo build --locked --workspace --all-features --all-targets
         env:
-          RUSTFLAGS: '-D warnings'
+          RUSTFLAGS: "-D warnings"
 
   cargo-clippy:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -291,11 +316,13 @@ jobs:
           toolchain: ${{ env.RUST_VERSION }}
           components: clippy
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Check Clippy Linter
         run: cargo clippy --all-features --all-targets -- -D warnings
 
   cargo-toml-fmt-check:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest # Switching this runner to buildjet causes failure.
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -306,12 +333,12 @@ jobs:
         uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-toml-lint
-          version: '0.1'
+          version: "0.1"
       - name: Run Cargo.toml linter
         run: git ls-files | grep Cargo.toml$ | grep -v 'templates/' | xargs --verbose -n 1 cargo-toml-lint
 
   cargo-fmt-check:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -323,7 +350,7 @@ jobs:
         run: cargo fmt --all -- --check
 
   cargo-run-e2e-test:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     needs: get-fuel-core-version
     steps:
       - uses: actions/checkout@v3
@@ -333,6 +360,8 @@ jobs:
           toolchain: ${{ env.RUST_VERSION }}
           targets: "x86_64-unknown-linux-gnu, wasm32-unknown-unknown"
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install fuel-core for tests
         run: |
           curl -sSLf https://github.com/FuelLabs/fuel-core/releases/download/v${{ needs.get-fuel-core-version.outputs.fuel_core_version }}/fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu.tar.gz -L -o fuel-core.tar.gz
@@ -341,12 +370,12 @@ jobs:
           mv fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu/fuel-core /usr/local/bin/fuel-core
       - name: Cargo Run E2E Tests (Fuel VM)
         run: |
-          fuel-core run --db-type in-memory --debug --snapshot ./.github/workflows/local-testnode & 
+          fuel-core run --db-type in-memory --debug &
           sleep 5 &&
           cargo run --locked --release --bin test -- --locked
 
   cargo-run-e2e-test-release:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     needs: get-fuel-core-version
     steps:
       - uses: actions/checkout@v3
@@ -356,6 +385,8 @@ jobs:
           toolchain: ${{ env.RUST_VERSION }}
           targets: "x86_64-unknown-linux-gnu, wasm32-unknown-unknown"
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install fuel-core for tests
         run: |
           curl -sSLf https://github.com/FuelLabs/fuel-core/releases/download/v${{ needs.get-fuel-core-version.outputs.fuel_core_version }}/fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu.tar.gz -L -o fuel-core.tar.gz
@@ -364,12 +395,12 @@ jobs:
           mv fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu/fuel-core /usr/local/bin/fuel-core
       - name: Cargo Run E2E Tests (Fuel VM)
         run: |
-          fuel-core run --db-type in-memory --debug --snapshot ./.github/workflows/local-testnode & 
+          fuel-core run --db-type in-memory --debug &
           sleep 5 &&
           cargo run --locked --release --bin test -- --locked --release
 
   cargo-run-e2e-test-evm:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -378,20 +409,10 @@ jobs:
           toolchain: ${{ env.RUST_VERSION }}
           targets: "x86_64-unknown-linux-gnu, wasm32-unknown-unknown"
       - uses: Swatinem/rust-cache@v2
-      - name: Cargo Run E2E Tests (EVM)
-        run: cargo run --locked --release --bin test -- --target evm --locked --no-encoding-v1
-
-  cargo-run-e2e-test-midenvm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install toolchain
-        uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: ${{ env.RUST_VERSION }}
-      - uses: Swatinem/rust-cache@v2
+          cache-provider: "buildjet"
       - name: Cargo Run E2E Tests (EVM)
-        run: cargo run --locked --release --bin test -- --target midenvm --locked --no-encoding-v1
+        run: cargo run --locked --release --bin test -- --target evm --locked --no-encoding-v1
 
   # TODO: Remove this upon merging std tests with the rest of the E2E tests.
   cargo-test-lib-std:
@@ -402,6 +423,7 @@ jobs:
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_VERSION }}
+          targets: "x86_64-unknown-linux-gnu, wasm32-unknown-unknown"
       - uses: buildjet/cache@v3
         with:
           path: |
@@ -414,7 +436,7 @@ jobs:
         run: cargo test --locked --release --manifest-path ./test/src/sdk-harness/Cargo.toml -- --nocapture
 
   forc-run-benchmarks:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     permissions:
       contents: write
     steps:
@@ -424,6 +446,8 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
       - name: Run benchmarks
@@ -446,12 +470,12 @@ jobs:
         run: ./benchmark.sh --prepare-for-commit
       - uses: EndBug/add-and-commit@v9
         with:
-          cwd: './performance-data'
-          message: 'Updated benchmark data'
+          cwd: "./performance-data"
+          message: "Updated benchmark data"
           default_author: github_actions
 
   forc-unit-tests:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -459,13 +483,19 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
-      - name: Run Unit Tests
-        run: forc build --path sway-lib-core && forc test --path sway-lib-core && forc build --path sway-lib-std && forc test --path sway-lib-std && forc build --path test/src/in_language_tests & forc test --path test/src/in_language_tests
+      - name: Run Core Unit Tests
+        run: forc build --path sway-lib-core && forc test --path sway-lib-core
+      - name: Run Std Unit Tests
+        run: forc build --path sway-lib-std && forc test --path sway-lib-std
+      - name: Run In Language Unit Tests
+        run: forc build --path test/src/in_language_tests && forc test --path test/src/in_language_tests
 
   forc-pkg-fuels-deps-check:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -473,15 +503,14 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
-
-      - name: Install cargo-deps
-        run: cargo install cargo-deps
+        with:
+          cache-provider: "buildjet"
 
       # We require this check to avoid cyclic dependencies between 'fuels' and 'forc-pkg'.
       # Detailed explanation is found in the echo below.
       - name: Check 'forc-pkg' dependencies for 'fuels' crates
         run: |
-          deps=$(cargo deps --manifest-path forc-pkg/Cargo.toml)
+          deps=$(cargo tree --manifest-path forc-pkg/Cargo.toml)
 
           case "$deps" in
             *fuels*)
@@ -499,7 +528,7 @@ jobs:
               ;;
           esac
   cargo-test-forc-debug:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     needs: get-fuel-core-version
     steps:
       - uses: actions/checkout@v3
@@ -509,6 +538,8 @@ jobs:
           toolchain: ${{ env.RUST_VERSION }}
           targets: "x86_64-unknown-linux-gnu, wasm32-unknown-unknown"
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install fuel-core for tests
         run: |
           curl -sSLf https://github.com/FuelLabs/fuel-core/releases/download/v${{ needs.get-fuel-core-version.outputs.fuel_core_version }}/fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu.tar.gz -L -o fuel-core.tar.gz
@@ -517,19 +548,58 @@ jobs:
           mv fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu/fuel-core /usr/local/bin/fuel-core
       - name: Run tests
         run: cargo test --locked --release -p forc-debug
-  cargo-test-sway-lsp:
-    runs-on: ubuntu-latest
+  cargo-test-forc-client:
+    runs-on: buildjet-4vcpu-ubuntu-2204
+    needs: get-fuel-core-version
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_VERSION }}
+          targets: "x86_64-unknown-linux-gnu, wasm32-unknown-unknown"
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
+      - name: Install fuel-core for tests
+        run: |
+          curl -sSLf https://github.com/FuelLabs/fuel-core/releases/download/v${{ needs.get-fuel-core-version.outputs.fuel_core_version }}/fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu.tar.gz -L -o fuel-core.tar.gz
+          tar -xvf fuel-core.tar.gz
+          chmod +x fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu/fuel-core
+          mv fuel-core-${{ needs.get-fuel-core-version.outputs.fuel_core_version }}-x86_64-unknown-linux-gnu/fuel-core /usr/local/bin/fuel-core
+      - name: Run tests
+        run: cargo test --locked --release -p forc-client -- --test-threads 1
+  cargo-test-sway-lsp:
+    runs-on: buildjet-4vcpu-ubuntu-2204
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Rust and cargo-nextest
+        uses: moonrepo/setup-rust@v0
+        with:
+          channel: stable
+          cache-target: release
+          bins: cargo-nextest
       - name: Run sway-lsp tests sequentially
-        run: cargo test --locked --release -p sway-lsp -- --nocapture --test-threads=1
+        env:
+          RUST_BACKTRACE: full
+        run: cargo nextest run --locked --release -p sway-lsp --no-capture --profile ci --config-file sway-lsp/tests/nextest.toml
+  cargo-test-forc:
+    runs-on: buildjet-4vcpu-ubuntu-2204
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
+      - name: Run forc tests separately 
+        env:
+          RUST_BACKTRACE: full
+        run: cargo test --locked --release -p forc -- --nocapture
   cargo-test-workspace:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -537,10 +607,12 @@ jobs:
         with:
           toolchain: ${{ env.RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Run tests
-        run: cargo test --locked --release --workspace --exclude forc-debug --exclude sway-lsp
+        run: cargo test --locked --release --workspace --exclude forc-debug --exclude sway-lsp --exclude forc-client --exclude forc
   cargo-unused-deps-check:
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v3
       - name: Install toolchain
@@ -549,6 +621,8 @@ jobs:
           # `cargo-udeps` requires nightly to run
           toolchain: ${{ env.NIGHTLY_RUST_VERSION }}
       - uses: Swatinem/rust-cache@v2
+        with:
+          cache-provider: "buildjet"
       - name: Install cargo-udeps
         run: cargo install --locked cargo-udeps
       - name: Check Unused Deps
@@ -571,7 +645,7 @@ jobs:
         cargo-test-sway-lsp,
         cargo-unused-deps-check,
       ]
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - name: Notify Slack On Failure
         uses: ravsamhq/notify-slack-action@v2
@@ -579,10 +653,10 @@ jobs:
         with:
           status: ${{ job.status }}
           token: ${{ secrets.GITHUB_TOKEN }}
-          notification_title: '{workflow} has {status_message}'
-          message_format: '{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>'
-          footer: ''
-          notify_when: 'failure'
+          notification_title: "{workflow} has {status_message}"
+          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>"
+          footer: ""
+          notify_when: "failure"
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
 
@@ -590,7 +664,7 @@ jobs:
   # This is a separate job because we want this to fail fast if something is invalid here.
   pre-publish-check:
     if: github.event_name == 'release' && github.event.action == 'published'
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
@@ -603,28 +677,7 @@ jobs:
       - name: Verify tag version
         run: |
           cargo install toml-cli
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-pkg/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-client/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-debug/Cargo.toml          
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-doc/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-fmt/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-lsp/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-tx/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-plugins/forc-crypto/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-test/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-tracing/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} forc-util/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-ast/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-core/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-error/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-ir/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-ir/sway-ir-macros/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-lsp/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-parse/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-types/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} sway-utils/Cargo.toml
-          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }} swayfmt/Cargo.toml
+          ./.github/workflows/scripts/verify_tag.sh ${{ github.ref_name }}
 
       - name: Notify if Job Fails
         uses: ravsamhq/notify-slack-action@v2
@@ -632,10 +685,10 @@ jobs:
         with:
           status: ${{ job.status }}
           token: ${{ secrets.GITHUB_TOKEN }}
-          notification_title: '{workflow} has {status_message}'
-          message_format: '{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>'
-          footer: ''
-          notify_when: 'failure'
+          notification_title: "{workflow} has {status_message}"
+          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>"
+          footer: ""
+          notify_when: "failure"
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
 
@@ -671,7 +724,7 @@ jobs:
           toolchain: ${{ env.RUST_VERSION }}
 
       - name: Publish crate
-        uses: xgreenx/publish-crates@v1
+        uses: FuelLabs/publish-crates@v1
         with:
           publish-delay: 30000
           registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
@@ -682,10 +735,10 @@ jobs:
         with:
           status: ${{ job.status }}
           token: ${{ secrets.GITHUB_TOKEN }}
-          notification_title: '{workflow} has {status_message}'
-          message_format: '{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>'
-          footer: ''
-          notify_when: 'failure'
+          notification_title: "{workflow} has {status_message}"
+          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>"
+          footer: ""
+          notify_when: "failure"
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
 
@@ -707,7 +760,7 @@ jobs:
         cargo-unused-deps-check,
       ]
     if: github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     permissions:
       contents: read
       packages: write
@@ -759,17 +812,17 @@ jobs:
         with:
           status: ${{ job.status }}
           token: ${{ secrets.GITHUB_TOKEN }}
-          notification_title: '{workflow} has {status_message}'
-          message_format: '{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>'
-          footer: ''
-          notify_when: 'failure'
+          notification_title: "{workflow} has {status_message}"
+          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>"
+          footer: ""
+          notify_when: "failure"
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
 
   build-publish-release-image:
     # Build & Publish Docker Image Per Sway Release
     needs: publish
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
     permissions:
       contents: read
       packages: write
@@ -814,10 +867,10 @@ jobs:
         with:
           status: ${{ job.status }}
           token: ${{ secrets.GITHUB_TOKEN }}
-          notification_title: '{workflow} has {status_message}'
-          message_format: '{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>'
-          footer: ''
-          notify_when: 'failure'
+          notification_title: "{workflow} has {status_message}"
+          message_format: "{emoji} *{workflow}* {status_message} in <{repo_url}|{repo}> : <{run_url}|View Run Results>"
+          footer: ""
+          notify_when: "failure"
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_NOTIFY_BUILD }}
 
@@ -862,13 +915,13 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-          key: '${{ matrix.job.target }}'
+          key: "${{ matrix.job.target }}"
 
       - name: Use Cross
         uses: baptiste0928/cargo-install@v1
         with:
           crate: cross
-          cache-key: '${{ matrix.job.target }}'
+          cache-key: "${{ matrix.job.target }}"
 
       - name: Build forc binaries
         run: |
diff --git a/.github/workflows/local-testnode/chain_config.json b/.github/workflows/local-testnode/chain_config.json
deleted file mode 100644
index 334f6f89508..00000000000
--- a/.github/workflows/local-testnode/chain_config.json
+++ /dev/null
@@ -1,271 +0,0 @@
-{
-  "chain_name": "Local network",
-  "consensus_parameters": {
-    "V1": {
-      "tx_params": {
-        "V1": {
-          "max_inputs": 255,
-          "max_outputs": 255,
-          "max_witnesses": 255,
-          "max_gas_per_tx": 100000000,
-          "max_size": 262144,
-          "max_bytecode_subsections": 256
-        }
-      },
-      "predicate_params": {
-        "V1": {
-          "max_predicate_length": 102400,
-          "max_predicate_data_length": 102400,
-          "max_message_data_length": 102400,
-          "max_gas_per_predicate": 100000000
-        }
-      },
-      "script_params": {
-        "V1": {
-          "max_script_length": 102400,
-          "max_script_data_length": 102400
-        }
-      },
-      "contract_params": {
-        "V1": {
-          "contract_max_size": 262144,
-          "max_storage_slots": 1760
-        }
-      },
-      "fee_params": {
-        "V1": {
-          "gas_price_factor": 92,
-          "gas_per_byte": 63
-        }
-      },
-      "chain_id": 0,
-      "gas_costs": {
-        "V1": {
-          "add": 2,
-          "addi": 2,
-          "aloc": 2,
-          "and": 2,
-          "andi": 2,
-          "bal": 86,
-          "bhei": 2,
-          "bhsh": 2,
-          "burn": 25770,
-          "cb": 2,
-          "cfei": 2,
-          "cfsi": 2,
-          "div": 2,
-          "divi": 2,
-          "eck1": 3114,
-          "ecr1": 42270,
-          "ed19": 2878,
-          "eq": 2,
-          "exp": 2,
-          "expi": 2,
-          "flag": 1,
-          "gm": 2,
-          "gt": 2,
-          "gtf": 12,
-          "ji": 2,
-          "jmp": 2,
-          "jne": 2,
-          "jnei": 2,
-          "jnzi": 2,
-          "jmpf": 1,
-          "jmpb": 1,
-          "jnzf": 1,
-          "jnzb": 1,
-          "jnef": 1,
-          "jneb": 1,
-          "lb": 2,
-          "log": 165,
-          "lt": 2,
-          "lw": 2,
-          "mint": 29024,
-          "mlog": 2,
-          "mod": 2,
-          "modi": 2,
-          "move": 2,
-          "movi": 2,
-          "mroo": 4,
-          "mul": 2,
-          "muli": 2,
-          "mldv": 3,
-          "noop": 1,
-          "not": 2,
-          "or": 2,
-          "ori": 2,
-          "poph": 3,
-          "popl": 3,
-          "pshh": 4,
-          "pshl": 4,
-          "ret_contract": 134,
-          "rvrt_contract": 153,
-          "sb": 2,
-          "sll": 2,
-          "slli": 2,
-          "srl": 2,
-          "srli": 2,
-          "srw": 209,
-          "sub": 2,
-          "subi": 2,
-          "sw": 2,
-          "sww": 22501,
-          "time": 50,
-          "tr": 33912,
-          "tro": 24294,
-          "wdcm": 2,
-          "wqcm": 3,
-          "wdop": 3,
-          "wqop": 3,
-          "wdml": 3,
-          "wqml": 4,
-          "wddv": 5,
-          "wqdv": 6,
-          "wdmd": 10,
-          "wqmd": 17,
-          "wdam": 9,
-          "wqam": 11,
-          "wdmm": 10,
-          "wqmm": 10,
-          "xor": 2,
-          "xori": 2,
-          "call": {
-            "LightOperation": {
-              "base": 18190,
-              "units_per_gas": 5
-            }
-          },
-          "ccp": {
-            "LightOperation": {
-              "base": 48,
-              "units_per_gas": 22
-            }
-          },
-          "croo": {
-            "LightOperation": {
-              "base": 131,
-              "units_per_gas": 2
-            }
-          },
-          "csiz": {
-            "LightOperation": {
-              "base": 45,
-              "units_per_gas": 237
-            }
-          },
-          "k256": {
-            "LightOperation": {
-              "base": 37,
-              "units_per_gas": 3
-            }
-          },
-          "ldc": {
-            "LightOperation": {
-              "base": 39,
-              "units_per_gas": 68
-            }
-          },
-          "logd": {
-            "LightOperation": {
-              "base": 565,
-              "units_per_gas": 2
-            }
-          },
-          "mcl": {
-            "LightOperation": {
-              "base": 3,
-              "units_per_gas": 564
-            }
-          },
-          "mcli": {
-            "LightOperation": {
-              "base": 3,
-              "units_per_gas": 560
-            }
-          },
-          "mcp": {
-            "LightOperation": {
-              "base": 4,
-              "units_per_gas": 185
-            }
-          },
-          "mcpi": {
-            "LightOperation": {
-              "base": 9,
-              "units_per_gas": 455
-            }
-          },
-          "meq": {
-            "LightOperation": {
-              "base": 3,
-              "units_per_gas": 766
-            }
-          },
-          "retd_contract": {
-            "LightOperation": {
-              "base": 485,
-              "units_per_gas": 3
-            }
-          },
-          "s256": {
-            "LightOperation": {
-              "base": 42,
-              "units_per_gas": 3
-            }
-          },
-          "scwq": {
-            "HeavyOperation": {
-              "base": 21672,
-              "gas_per_unit": 22146
-            }
-          },
-          "smo": {
-            "LightOperation": {
-              "base": 44437,
-              "units_per_gas": 1
-            }
-          },
-          "srwq": {
-            "HeavyOperation": {
-              "base": 239,
-              "gas_per_unit": 234
-            }
-          },
-          "swwq": {
-            "HeavyOperation": {
-              "base": 22724,
-              "gas_per_unit": 21231
-            }
-          },
-          "contract_root": {
-            "LightOperation": {
-              "base": 42,
-              "units_per_gas": 2
-            }
-          },
-          "state_root": {
-            "HeavyOperation": {
-              "base": 323,
-              "gas_per_unit": 169
-            }
-          },
-          "new_storage_per_byte": 63,
-          "vm_initialization": {
-            "HeavyOperation": {
-              "base": 5254820,
-              "gas_per_unit": 0
-            }
-          }
-        }
-      },
-      "base_asset_id": "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07",
-      "block_gas_limit": 100000000,
-      "privileged_address": "9f0e19d6c2a6283a3222426ab2630d35516b1799b503f37b02105bebe1b8a3e9"
-    }
-  },
-  "consensus": {
-    "PoA": {
-      "signing_key": "e0a9fcde1b73f545252e01b30b50819eb9547d07531fa3df0385c5695736634d"
-    }
-  }
-}
\ No newline at end of file
diff --git a/.github/workflows/local-testnode/metadata.json b/.github/workflows/local-testnode/metadata.json
deleted file mode 100644
index 9d12c38b64e..00000000000
--- a/.github/workflows/local-testnode/metadata.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "chain_config": "chain_config.json",
-  "table_encoding": {
-    "Json": {
-      "filepath": "state_config.json"
-    }
-  }
-}
diff --git a/.github/workflows/local-testnode/state_config.json b/.github/workflows/local-testnode/state_config.json
deleted file mode 100644
index 879ee797e15..00000000000
--- a/.github/workflows/local-testnode/state_config.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-  "coins": [
-    {
-      "tx_id": "0000000000000000000000000000000000000000000000000000000000000001",
-      "output_index": 0,
-      "tx_pointer_block_height": 0,
-      "tx_pointer_tx_idx": 0,
-      "owner": "6b63804cfbf9856e68e5b6e7aef238dc8311ec55bec04df774003a2c96e0418e",
-      "amount": 1152921504606846976,
-      "asset_id": "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
-    }
-  ],
-  "messages": [],
-  "contracts": [
-    {
-      "contract_id": "7777777777777777777777777777777777777777777777777777777777777777",
-      "code": "900000097b4b30b2437b0073e5ba5a9324cf55831d180a89f66332b541827e12e647b7516140000a504d00205d4d30001a4860004945048076440001240400005050c0043d51345024040000",
-      "tx_id": "0000000000000000000000000000000000000000000000000000000000000000",
-      "output_index": 0,
-      "tx_pointer_block_height": 0,
-      "tx_pointer_tx_idx": 0,
-      "states": [],
-      "balances": []
-    },
-    {
-      "contract_id": "0x7e2becd64cd598da59b4d1064b711661898656c6b1f4918a787156b8965dc83c",
-      "code": "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",
-      "tx_id": "0000000000000000000000000000000000000000000000000000000000000001",
-      "output_index": 0,
-      "tx_pointer_block_height": 0,
-      "tx_pointer_tx_idx": 0,
-      "states": [],
-      "balances": []
-    }
-  ],
-  "last_block": null
-}
\ No newline at end of file
diff --git a/.github/workflows/local-testnode/state_transition_bytecode.wasm b/.github/workflows/local-testnode/state_transition_bytecode.wasm
deleted file mode 100755
index 7547b6d1b09..00000000000
Binary files a/.github/workflows/local-testnode/state_transition_bytecode.wasm and /dev/null differ
diff --git a/.github/workflows/scripts/verify_tag.sh b/.github/workflows/scripts/verify_tag.sh
index e029f651988..6277011a708 100755
--- a/.github/workflows/scripts/verify_tag.sh
+++ b/.github/workflows/scripts/verify_tag.sh
@@ -6,30 +6,66 @@ err() {
 }
 
 status() {
-    WIDTH=12
-    printf "\e[32m\e[1m%${WIDTH}s\e[0m %s\n" "$1" "$2"
+    local width=12
+    printf "\e[32m\e[1m%${width}s\e[0m %s\n" "$1" "$2"
+}
+
+get_toml_version () {
+    local toml_path="$1"
+
+    local manifest="Cargo.toml"
+    echo $(toml get $manifest $toml_path | tr -d '"')
+}
+
+check_version () {
+    local ref=$1
+    local toml_path=$2
+
+    # strip preceeding 'v' if it exists on tag
+    ref=${ref/#v}
+
+    local toml_version=$(get_toml_version "$toml_path")
+  
+    if [ "$toml_version" != "$ref" ]; then
+        err "Crate version $toml_version for $toml_path, doesn't match tag version $ref"
+        exit 1
+    else
+      status "Crate version for $toml_path matches tag $toml_version"
+    fi
 }
 
 REF=$1
-MANIFEST=$2
 
 if [ -z "$REF" ]; then
     err "Expected ref to be set"
     exit 1
 fi
 
-if [ -z "$MANIFEST" ]; then
-    err "Expected manifest to be set"
-    exit 1
-fi
-
-# strip preceeding 'v' if it exists on tag
-REF=${REF/#v}
-TOML_VERSION=$(toml get $MANIFEST package.version | tr -d '"')
-
-if [ "$TOML_VERSION" != "$REF" ]; then
-    err "Crate version $TOML_VERSION, doesn't match tag version $REF"
-    exit 1
-else
-  status "Crate version matches tag $TOML_VERSION"
-fi
+for toml_path in \
+    "workspace.package.version" \
+    "workspace.dependencies.forc.version" \
+    "workspace.dependencies.forc-pkg.version" \
+    "workspace.dependencies.forc-test.version" \
+    "workspace.dependencies.forc-tracing.version" \
+    "workspace.dependencies.forc-util.version" \
+    "workspace.dependencies.forc-plugins.version" \
+    "workspace.dependencies.forc-client.version" \
+    "workspace.dependencies.forc-crypto.version" \
+    "workspace.dependencies.forc-debug.version" \
+    "workspace.dependencies.forc-doc.version" \
+    "workspace.dependencies.forc-fmt.version" \
+    "workspace.dependencies.forc-lsp.version" \
+    "workspace.dependencies.forc-tx.version" \
+    "workspace.dependencies.sway-ast.version" \
+    "workspace.dependencies.sway-core.version" \
+    "workspace.dependencies.sway-error.version" \
+    "workspace.dependencies.sway-lsp.version" \
+    "workspace.dependencies.sway-parse.version" \
+    "workspace.dependencies.sway-types.version" \
+    "workspace.dependencies.sway-utils.version" \
+    "workspace.dependencies.swayfmt.version" \
+    "workspace.dependencies.sway-ir.version" \
+    "workspace.dependencies.sway-ir-macros.version" \
+; do
+    check_version $REF $toml_path
+done
diff --git a/.gitignore b/.gitignore
index 3de2d377b4e..3b09835e4ac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -32,3 +32,6 @@ forc-plugins/forc-debug/tests/**/Forc.lock
 # Generated files in example directories
 examples/**/*/Forc.lock
 docs/reference/src/code/examples/**/*/Forc.lock
+
+# Insta files
+*.snap.new
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000000..eb5c4aa3642
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,23 @@
+// Configuration for debugging the Sway Language Server (forc-lsp)
+// Usage instructions:
+// 1. Ensure you've built forc-lsp with debug symbols:
+//    cargo build -p forc-lsp
+// 2. Install the debug version:
+//    cargo install --path ./forc-plugins/forc-lsp --debug
+// 3. Open your Sway project in a separate VSCode window (this starts forc-lsp)
+// 4. In the forc-lsp project window, set breakpoints in the code
+// 5. Go to Run and Debug view, select "Attach to forc-lsp", and start debugging
+// 6. When prompted, select the forc-lsp process
+// 7. Debug forc-lsp as it responds to actions in your Sway project
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "attach",
+            "name": "Attach to forc-lsp",
+            "pid": "${command:pickProcess}",
+            "program": "${env:HOME}/.cargo/bin/forc-lsp"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 81fc6bbc554..4b067e99ad1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14,18 +14,18 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.21.0"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
 dependencies = [
  "gimli",
 ]
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
 [[package]]
 name = "aes"
@@ -38,6 +38,17 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "ahash"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "version_check",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.11"
@@ -45,7 +56,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if 1.0.0",
- "getrandom 0.2.15",
+ "getrandom",
  "once_cell",
  "version_check",
  "zerocopy",
@@ -66,6 +77,79 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
+[[package]]
+name = "alloy-eip2930"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0069cf0642457f87a01a014f6dc29d5d893cd4fd8fddf0c3cdfad1bb3ebafc41"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "serde",
+]
+
+[[package]]
+name = "alloy-eip7702"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea59dc42102bc9a1905dc57901edc6dd48b9f38115df86c7d252acba70d71d04"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "alloy-primitives"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f35429a652765189c1c5092870d8360ee7b7769b09b06d89ebaefd34676446"
+dependencies = [
+ "alloy-rlp",
+ "bytes",
+ "cfg-if 1.0.0",
+ "const-hex",
+ "derive_more 1.0.0",
+ "foldhash",
+ "hashbrown 0.15.0",
+ "hex-literal",
+ "indexmap 2.6.0",
+ "itoa",
+ "k256",
+ "keccak-asm",
+ "paste",
+ "proptest",
+ "rand",
+ "ruint",
+ "rustc-hash 2.0.0",
+ "serde",
+ "sha3",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "alloy-rlp"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26154390b1d205a4a7ac7352aa2eb4f81f391399d4e2f546fb81a2f8bb383f62"
+dependencies = [
+ "alloy-rlp-derive",
+ "arrayvec",
+ "bytes",
+]
+
+[[package]]
+name = "alloy-rlp-derive"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d0f2d905ebd295e7effec65e5f6868d153936130ae718352771de3e7d03c75c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -108,9 +192,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -123,33 +207,33 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.3"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a64c907d4e79225ac72e2a354c9ce84d50ebb4586dee56c82b3ee73004f537f5"
+checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
 dependencies = [
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
 dependencies = [
  "anstyle",
  "windows-sys 0.52.0",
@@ -157,27 +241,151 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
 
 [[package]]
-name = "arrayref"
-version = "0.3.7"
+name = "arc-swap"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
 
 [[package]]
-name = "arrayvec"
-version = "0.5.2"
+name = "ark-ff"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6"
+dependencies = [
+ "ark-ff-asm 0.3.0",
+ "ark-ff-macros 0.3.0",
+ "ark-serialize 0.3.0",
+ "ark-std 0.3.0",
+ "derivative",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rustc_version 0.3.3",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
+dependencies = [
+ "ark-ff-asm 0.4.2",
+ "ark-ff-macros 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
+ "derivative",
+ "digest 0.10.7",
+ "itertools 0.10.5",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rustc_version 0.4.1",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671"
+dependencies = [
+ "ark-std 0.3.0",
+ "digest 0.9.0",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
+dependencies = [
+ "ark-std 0.4.0",
+ "digest 0.10.7",
+ "num-bigint",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
+dependencies = [
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
+dependencies = [
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "ascii"
@@ -208,114 +416,405 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
 
 [[package]]
-name = "async-trait"
-version = "0.1.80"
+name = "async-trait"
+version = "0.1.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "atomic-polyfill"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+dependencies = [
+ "critical-section",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "aurora-engine-modexp"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0aef7712851e524f35fbbb74fa6599c5cd8692056a1c36f9ca0d2001b670e7e5"
+dependencies = [
+ "hex",
+ "num",
+]
+
+[[package]]
+name = "auto_impl"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "aws-config"
+version = "1.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7198e6f03240fdceba36656d8be440297b6b82270325908c7381f37d826a74f6"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sdk-sso",
+ "aws-sdk-ssooidc",
+ "aws-sdk-sts",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "hex",
+ "http 0.2.12",
+ "ring",
+ "time",
+ "tokio",
+ "tracing",
+ "url",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-credential-types"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60e8f6b615cb5fc60a98132268508ad104310f0cfb25a1c22eee76efdf9154da"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-runtime"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a10d5c055aa540164d9561a0e2e74ad30f0dcf7393c3a92f6733ddf9c5762468"
+dependencies = [
+ "aws-credential-types",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "tracing",
+ "uuid 1.11.0",
+]
+
+[[package]]
+name = "aws-sdk-kms"
+version = "1.47.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "564a597a3c71a957d60a2e4c62c93d78ee5a0d636531e15b760acad983a5c18e"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-sso"
+version = "1.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc2faec3205d496c7e57eff685dd944203df7ce16a4116d0281c44021788a7b"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-ssooidc"
+version = "1.47.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c93c241f52bc5e0476e259c953234dab7e2a35ee207ee202e86c0095ec4951dc"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sdk-sts"
+version = "1.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b259429be94a3459fa1b00c5684faee118d74f9577cc50aebadc36e507c63b5f"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-query",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-smithy-xml",
+ "aws-types",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sigv4"
+version = "1.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc8db6904450bafe7473c6ca9123f88cc11089e41a025408f992db4e22d3be68"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-http",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "form_urlencoded",
+ "hex",
+ "hmac 0.12.1",
+ "http 0.2.12",
+ "http 1.1.0",
+ "once_cell",
+ "percent-encoding",
+ "sha2 0.10.8",
+ "time",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-async"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62220bc6e97f946ddd51b5f1361f78996e704677afc518a4ff66b7a72ea1378c"
+dependencies = [
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "aws-smithy-http"
+version = "0.60.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
+checksum = "5c8bc3e8fdc6b8d07d976e301c02fe553f72a39b7a9fea820e023268467d7ab6"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.65",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "pin-utils",
+ "tracing",
 ]
 
 [[package]]
-name = "atomic-polyfill"
-version = "1.0.3"
+name = "aws-smithy-json"
+version = "0.60.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+checksum = "4683df9469ef09468dad3473d129960119a0d3593617542b7d52086c8486f2d6"
 dependencies = [
- "critical-section",
+ "aws-smithy-types",
 ]
 
 [[package]]
-name = "atty"
-version = "0.2.14"
+name = "aws-smithy-query"
+version = "0.60.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+checksum = "f2fbd61ceb3fe8a1cb7352e42689cec5335833cd9f94103a61e98f9bb61c64bb"
 dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
+ "aws-smithy-types",
+ "urlencoding",
 ]
 
 [[package]]
-name = "auto_impl"
-version = "1.2.0"
+name = "aws-smithy-runtime"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
+checksum = "a065c0fe6fdbdf9f11817eb68582b2ab4aff9e9c39e986ae48f7ec576c6322db"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.65",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "fastrand",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "httparse",
+ "hyper 0.14.31",
+ "hyper-rustls 0.24.2",
+ "once_cell",
+ "pin-project-lite",
+ "pin-utils",
+ "rustls 0.21.12",
+ "tokio",
+ "tracing",
 ]
 
 [[package]]
-name = "autocfg"
-version = "1.3.0"
+name = "aws-smithy-runtime-api"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "e086682a53d3aa241192aa110fa8dfce98f2f5ac2ead0de84d41582c7e8fdb96"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-types",
+ "bytes",
+ "http 0.2.12",
+ "http 1.1.0",
+ "pin-project-lite",
+ "tokio",
+ "tracing",
+ "zeroize",
+]
 
 [[package]]
-name = "axum"
-version = "0.5.17"
+name = "aws-smithy-types"
+version = "1.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acee9fd5073ab6b045a275b3e709c163dd36c90685219cb21804a147b58dba43"
+checksum = "147100a7bea70fa20ef224a6bad700358305f5dc0f84649c53769761395b355b"
 dependencies = [
- "async-trait",
- "axum-core",
- "bitflags 1.3.2",
+ "base64-simd",
  "bytes",
- "futures-util",
- "http",
- "http-body",
- "hyper",
+ "bytes-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.1.0",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
  "itoa",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
+ "num-integer",
  "pin-project-lite",
+ "pin-utils",
+ "ryu",
  "serde",
- "serde_json",
- "serde_urlencoded",
- "sync_wrapper",
+ "time",
  "tokio",
- "tower",
- "tower-http",
- "tower-layer",
- "tower-service",
+ "tokio-util",
 ]
 
 [[package]]
-name = "axum-core"
-version = "0.2.9"
+name = "aws-smithy-xml"
+version = "0.60.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e5939e02c56fecd5c017c37df4238c0a839fa76b7f97acdd7efb804fd181cc"
+checksum = "ab0b0166827aa700d3dc519f72f8b3a91c35d0b8d042dc5d643a91e6f80648fc"
 dependencies = [
- "async-trait",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "mime",
- "tower-layer",
- "tower-service",
+ "xmlparser",
+]
+
+[[package]]
+name = "aws-types"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5221b91b3e441e6675310829fd8984801b772cb1546ef6c0e54dec9f1ac13fef"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "rustc_version 0.4.1",
+ "tracing",
 ]
 
 [[package]]
 name = "backtrace"
-version = "0.3.71"
+version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
+checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
 dependencies = [
  "addr2line",
- "cc",
  "cfg-if 1.0.0",
  "libc",
  "miniz_oxide",
  "object",
  "rustc-demangle",
  "serde",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -348,6 +847,16 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "base64-simd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
+dependencies = [
+ "outref",
+ "vsimd",
+]
+
 [[package]]
 name = "base64ct"
 version = "1.6.0"
@@ -398,9 +907,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 dependencies = [
  "serde",
 ]
@@ -427,67 +936,57 @@ dependencies = [
 ]
 
 [[package]]
-name = "blake2b_simd"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afa748e348ad3be8263be728124b24a24f268266f6f5d58af9d75f6a40b5c587"
-dependencies = [
- "arrayref",
- "arrayvec 0.5.2",
- "constant_time_eq 0.1.5",
-]
-
-[[package]]
-name = "blake2b_simd"
-version = "1.0.2"
+name = "block-buffer"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23285ad32269793932e830392f2fe2f83e26488fd3ec778883a93c8323735780"
+checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.4",
- "constant_time_eq 0.3.0",
+ "generic-array",
 ]
 
 [[package]]
-name = "blake2s_simd"
-version = "1.0.2"
+name = "block-buffer"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94230421e395b9920d23df13ea5d77a20e1725331f90fbbf6df6040b33f756ae"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.4",
- "constant_time_eq 0.3.0",
+ "generic-array",
 ]
 
 [[package]]
-name = "blake3"
-version = "1.5.1"
+name = "blst"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52"
+checksum = "4378725facc195f1a538864863f6de233b500a8862747e7f165078a419d5e874"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.4",
  "cc",
- "cfg-if 1.0.0",
- "constant_time_eq 0.3.0",
+ "glob",
+ "threadpool",
+ "zeroize",
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.9.0"
+name = "borsh"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+checksum = "a6362ed55def622cddc70a4746a68554d7b687713770de539e59a739b249f8ed"
 dependencies = [
- "generic-array",
+ "borsh-derive",
+ "cfg_aliases",
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.10.4"
+name = "borsh-derive"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+checksum = "c3ef8005764f53cd4dca619f5bf64cafd4664dada50ece25e4d81de54c80cc0b"
 dependencies = [
- "generic-array",
+ "once_cell",
+ "proc-macro-crate 3.2.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+ "syn_derive",
 ]
 
 [[package]]
@@ -502,12 +1001,12 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.9.1"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
+checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c"
 dependencies = [
  "memchr",
- "regex-automata 0.4.6",
+ "regex-automata 0.4.8",
  "serde",
 ]
 
@@ -523,6 +1022,39 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
 
+[[package]]
+name = "byte-unit"
+version = "5.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ac19bdf0b2665407c39d82dbc937e951e7e2001609f0fb32edd0af45a2d63e"
+dependencies = [
+ "rust_decimal",
+ "serde",
+ "utf8-width",
+]
+
+[[package]]
+name = "bytecheck"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
+dependencies = [
+ "bytecheck_derive",
+ "ptr_meta",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck_derive"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "bytecount"
 version = "0.6.8"
@@ -537,9 +1069,44 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.6.0"
+version = "1.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
+
+[[package]]
+name = "bytes-utils"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
+dependencies = [
+ "bytes",
+ "either",
+]
+
+[[package]]
+name = "c-kzg"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0307f72feab3300336fb803a57134159f6e20139af1357f36c54cb90d8e8928"
+dependencies = [
+ "blst",
+ "cc",
+ "glob",
+ "hex",
+ "libc",
+ "once_cell",
+ "serde",
+]
+
+[[package]]
+name = "caseless"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+checksum = "808dab3318747be122cb31d36de18d4d1c81277a76f8332a02b81a3d73463d7f"
+dependencies = [
+ "regex",
+ "unicode-normalization",
+]
 
 [[package]]
 name = "cast"
@@ -549,13 +1116,13 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.98"
+version = "1.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41c270e7540d725e65ac7f1b212ac8ce349719624d7bcff99f8e2e488e8cf03f"
+checksum = "b16803a61b81d9eabb7eae2588776c4c1e584b738ede45fdbb4c972cec1e9945"
 dependencies = [
  "jobserver",
  "libc",
- "once_cell",
+ "shlex",
 ]
 
 [[package]]
@@ -570,6 +1137,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chrono"
 version = "0.4.38"
@@ -582,7 +1155,7 @@ dependencies = [
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -614,15 +1187,14 @@ dependencies = [
 
 [[package]]
 name = "cid"
-version = "0.10.1"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd94671561e36e4e7de75f753f577edafb0e7c05d6e4547229fdf7938fbcd2c3"
+checksum = "3147d8272e8fa0ccd29ce51194dd98f79ddfb8191ba9e3409884e751798acf3a"
 dependencies = [
  "core2",
  "multibase",
- "multihash 0.18.1",
- "serde",
- "unsigned-varint",
+ "multihash 0.19.1",
+ "unsigned-varint 0.8.0",
 ]
 
 [[package]]
@@ -652,9 +1224,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.4"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -662,9 +1234,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.2"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
  "anstream",
  "anstyle",
@@ -675,50 +1247,48 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.5.2"
+version = "4.5.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd79504325bf38b10165b02e89b4347300f855f273c4cb30c4a3209e6583275e"
+checksum = "9646e2e245bf62f45d39a0f3f36f1171ad1ea0d6967fd114bca72cb02a8fcdfb"
 dependencies = [
- "clap 4.5.4",
+ "clap 4.5.20",
 ]
 
 [[package]]
 name = "clap_complete_fig"
-version = "4.5.0"
+version = "4.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54b3e65f91fabdd23cac3d57d39d5d938b4daabd070c335c006dccb866a61110"
+checksum = "d494102c8ff3951810c72baf96910b980fb065ca5d3101243e6a8dc19747c86b"
 dependencies = [
- "clap 4.5.4",
+ "clap 4.5.20",
  "clap_complete",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.5.4"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "clipboard-win"
-version = "4.5.0"
+version = "5.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362"
+checksum = "15efe7a882b08f34e38556b14f2fb3daa98769d06c7f0c1b076dfd0d983bc892"
 dependencies = [
  "error-code",
- "str-buf",
- "winapi",
 ]
 
 [[package]]
@@ -727,6 +1297,28 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
 
+[[package]]
+name = "codspeed"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "450a0e9df9df1c154156f4344f99d8f6f6e69d0fc4de96ef6e2e68b2ec3bce97"
+dependencies = [
+ "colored",
+ "libc",
+ "serde_json",
+]
+
+[[package]]
+name = "codspeed-criterion-compat"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eb1a6cb9c20e177fde58cdef97c1c7c9264eb1424fe45c4fccedc2fb078a569"
+dependencies = [
+ "codspeed",
+ "colored",
+ "criterion",
+]
+
 [[package]]
 name = "coins-bip32"
 version = "0.8.7"
@@ -781,9 +1373,9 @@ dependencies = [
 
 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
 
 [[package]]
 name = "colored"
@@ -808,6 +1400,12 @@ dependencies = [
  "unreachable",
 ]
 
+[[package]]
+name = "comma"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335"
+
 [[package]]
 name = "common-multipart-rfc7578"
 version = "0.6.0"
@@ -817,7 +1415,7 @@ dependencies = [
  "bytes",
  "futures-core",
  "futures-util",
- "http",
+ "http 0.2.12",
  "mime",
  "mime_guess",
  "rand",
@@ -826,15 +1424,15 @@ dependencies = [
 
 [[package]]
 name = "completest"
-version = "0.4.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8229e041ca8f8130ad7f0ce1afb9cfdb3033de7fd548e6422dbb2f4f12184f41"
+checksum = "410de1ffe61368aa040f599747584e9e3d19235cf4045be6159edb167ef45ddb"
 
 [[package]]
 name = "completest-pty"
-version = "0.5.0"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a6d1272e27f608f97616be67a2aed03ed8d73910b5df9a7f4a50c4ffd59d185"
+checksum = "fbd2f22a999db122bd2861c504aa363bbacaa32ebea29edf6924ee6cfe044313"
 dependencies = [
  "completest",
  "ptyprocess",
@@ -843,16 +1441,16 @@ dependencies = [
 
 [[package]]
 name = "comrak"
-version = "0.16.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784836d0812dade01579cc0cc9b1684847044e716fd7aa6bffbc172e42199500"
+checksum = "c93ab3577cca16b4a1d80a88c2e0cd8b6e969e51696f0bbb0d1dcb0157109832"
 dependencies = [
- "clap 4.5.4",
+ "caseless",
+ "clap 4.5.20",
+ "derive_builder",
  "entities",
  "memchr",
  "once_cell",
- "pest",
- "pest_derive",
  "regex",
  "shell-words",
  "slug",
@@ -871,26 +1469,28 @@ dependencies = [
  "encode_unicode 0.3.6",
  "lazy_static",
  "libc",
+ "unicode-width",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "constant_time_eq"
-version = "0.1.5"
+name = "const-hex"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+checksum = "0121754e84117e65f9d90648ee6aa4882a6e63110307ab73967a4c5e7e69e586"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "hex",
+ "proptest",
+ "serde",
+]
 
 [[package]]
-name = "constant_time_eq"
-version = "0.3.0"
+name = "const-oid"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
 [[package]]
 name = "convert_case"
@@ -938,9 +1538,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "core2"
@@ -962,15 +1562,15 @@ dependencies = [
 
 [[package]]
 name = "countme"
-version = "2.0.4"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "328b822bdcba4d4e402be8d9adb6eebf269f969f8eadef977a553ff3c4fbcb58"
+checksum = "7704b5fdd17b18ae31c4c1da5a2e0305a2bf17b5249300a9ee9ed7b72114c636"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
 dependencies = [
  "libc",
 ]
@@ -993,7 +1593,7 @@ dependencies = [
  "anes",
  "cast",
  "ciborium",
- "clap 4.5.4",
+ "clap 4.5.20",
  "criterion-plot",
  "is-terminal",
  "itertools 0.10.5",
@@ -1022,9 +1622,9 @@ dependencies = [
 
 [[package]]
 name = "critical-section"
-version = "1.1.2"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7059fff8937831a9ae6f0fe4d658ffabf58f2ca96aa9dec1c889f936f705f216"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
 
 [[package]]
 name = "crossbeam-channel"
@@ -1119,15 +1719,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ct-logs"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1a816186fa68d9e426e3cb4ae4dff1fcd8e4a2c34b781bf7a822574a0d0aac8"
-dependencies = [
- "sct 0.6.1",
-]
-
 [[package]]
 name = "ctr"
 version = "0.9.2"
@@ -1139,17 +1730,16 @@ dependencies = [
 
 [[package]]
 name = "curve25519-dalek"
-version = "4.1.2"
+version = "4.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
  "curve25519-dalek-derive",
  "digest 0.10.7",
  "fiat-crypto",
- "platforms",
- "rustc_version",
+ "rustc_version 0.4.1",
  "subtle",
 ]
 
@@ -1161,7 +1751,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -1171,7 +1761,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1afa0591b1021e427e548a1f0f147fe6168f6c7c7f7006bace77f28856051b8"
 dependencies = [
  "cynic-proc-macros",
- "reqwest",
+ "reqwest 0.11.27",
  "serde",
  "serde_json",
  "static_assertions",
@@ -1227,12 +1817,12 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core 0.20.9",
- "darling_macro 0.20.9",
+ "darling_core 0.20.10",
+ "darling_macro 0.20.10",
 ]
 
 [[package]]
@@ -1251,16 +1841,16 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim 0.11.1",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -1276,22 +1866,36 @@ dependencies = [
 
 [[package]]
 name = "darling_macro"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core 0.20.9",
+ "darling_core 0.20.10",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "dashmap"
+version = "5.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if 1.0.0",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core 0.9.10",
 ]
 
 [[package]]
 name = "dashmap"
-version = "5.5.3"
+version = "6.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
  "cfg-if 1.0.0",
+ "crossbeam-utils",
  "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
@@ -1366,17 +1970,69 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "derive_builder"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
+dependencies = [
+ "darling 0.20.10",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
+dependencies = [
+ "derive_builder_core",
+ "syn 2.0.79",
+]
+
 [[package]]
 name = "derive_more"
-version = "0.99.17"
+version = "0.99.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
 dependencies = [
  "convert_case",
  "proc-macro2",
  "quote",
- "rustc_version",
- "syn 1.0.109",
+ "rustc_version 0.4.1",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+ "unicode-xid",
 ]
 
 [[package]]
@@ -1387,15 +2043,28 @@ checksum = "339544cc9e2c4dc3fc7149fd630c5f22263a4fdf18a98afd0075784968b5cf00"
 
 [[package]]
 name = "devault"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffc1d36b1abcd53bf307972de38ed2da0a57ddeb762b141420067149d3952c9a"
+checksum = "b6bd8149b97caf4a72d9dd6b09a4192fcc07c2551ef5c949ea488554a9994649"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "dialoguer"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658bce805d770f407bc62102fca7c2c64ceef2fbcb2b8bd19d2765ce093980de"
+dependencies = [
+ "console",
+ "shell-words",
+ "tempfile",
+ "thiserror",
+ "zeroize",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
@@ -1437,31 +2106,20 @@ checksum = "363641827cb8d8387a69364aa2f85433db83b8b00270ed2c786235d83bf0aa0a"
 
 [[package]]
 name = "dirs"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fd78930633bd1c6e35c4b42b1df7b0cbc6bc191146e512bb3bedf243fcc3901"
-dependencies = [
- "libc",
- "redox_users 0.3.5",
- "winapi",
-]
-
-[[package]]
-name = "dirs"
-version = "3.0.2"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30baa043103c9d0c2a57cf537cc2f35623889dc0d405e6c3cccfadbc81c71309"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
 dependencies = [
- "dirs-sys",
+ "dirs-sys 0.3.7",
 ]
 
 [[package]]
 name = "dirs"
-version = "4.0.0"
+version = "5.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
 dependencies = [
- "dirs-sys",
+ "dirs-sys 0.4.1",
 ]
 
 [[package]]
@@ -1481,10 +2139,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
 dependencies = [
  "libc",
- "redox_users 0.4.5",
+ "redox_users",
  "winapi",
 ]
 
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "dirs-sys-next"
 version = "0.1.2"
@@ -1492,7 +2162,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
 dependencies = [
  "libc",
- "redox_users 0.4.5",
+ "redox_users",
  "winapi",
 ]
 
@@ -1520,6 +2190,24 @@ version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcbb2bf8e87535c23f7a8a321e364ce21462d0ff10cb6407820e8e96dfff6653"
 
+[[package]]
+name = "duct"
+version = "0.13.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4ab5718d1224b63252cd0c6f74f6480f9ffeb117438a2e0f5cf6d9a4798929c"
+dependencies = [
+ "libc",
+ "once_cell",
+ "os_pipe",
+ "shared_child",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+
 [[package]]
 name = "ecdsa"
 version = "0.16.9"
@@ -1569,9 +2257,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "elliptic-curve"
@@ -1598,6 +2286,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
 
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
 [[package]]
 name = "encode_unicode"
 version = "0.3.6"
@@ -1648,7 +2342,7 @@ checksum = "a1ab991c1362ac86c61ab6f556cff143daa22e5a15e4e189df818b2fd19fe65b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -1661,14 +2355,25 @@ dependencies = [
  "num-traits",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "enumn"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f9ed6b3789237c8a0c1c505af1c7eb2c560df6186f01b098c3a1064ea532f38"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "env_filter"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea"
+checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
 dependencies = [
  "log",
  "regex",
@@ -1676,9 +2381,9 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.11.3"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b35839ba51819680ba087cd351788c9a3c476841207e0b8cee0b04722343b9"
+checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1715,19 +2420,21 @@ dependencies = [
 
 [[package]]
 name = "error-code"
-version = "2.3.1"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21"
-dependencies = [
- "libc",
- "str-buf",
-]
+checksum = "a5d9305ccc6942a704f4335694ecd3de2ea531b114ac2d51f5f843750787a92f"
+
+[[package]]
+name = "escape8259"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5692dd7b5a1978a5aeb0ce83b7655c58ca8efdcb79d21036ea249da95afec2c6"
 
 [[package]]
 name = "escargot"
-version = "0.5.10"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f474c6844cbd04e783d0f25757583db4f491770ca618bedf2fb01815fc79939"
+checksum = "c000f23e9d459aef148b7267e02b03b94a0aaacf4ec64c65612f67e02f525fb6"
 dependencies = [
  "log",
  "once_cell",
@@ -1754,7 +2461,7 @@ dependencies = [
  "sha2 0.10.8",
  "sha3",
  "thiserror",
- "uuid",
+ "uuid 0.8.2",
 ]
 
 [[package]]
@@ -1792,16 +2499,17 @@ checksum = "b90ca2580b73ab6a1f724b76ca11ab632df820fd6040c336200d2c1df7b3c82c"
 
 [[package]]
 name = "eventsource-client"
-version = "0.10.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9146112ee3ce031aa5aebe3e049e10b1d353b9c7630cc6be488c2c62cc5d9c42"
+checksum = "43ddc25e1ad2cc0106d5e2d967397b4fb2068a66677ee9b0eea4600e5cfe8fb4"
 dependencies = [
  "futures",
- "hyper",
- "hyper-rustls 0.22.1",
+ "hyper 0.14.31",
+ "hyper-rustls 0.24.2",
  "hyper-timeout",
  "log",
  "pin-project",
+ "rand",
  "tokio",
 ]
 
@@ -1823,7 +2531,7 @@ checksum = "dd65f1b59dd22d680c7a626cc4a000c1e03d241c51c3e034d2bc9f1e90734f9b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -1842,20 +2550,27 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "faster-hex"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2a2b11eda1d40935b26cf18f6833c526845ae8c41e58d09af6adeb6f0269183"
+
 [[package]]
 name = "fastrand"
-version = "2.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 
 [[package]]
-name = "fd-lock"
-version = "2.0.0"
+name = "fastrlp"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0010f02effd88c702318c5dde0463206be67495d0b4d906ba7c0a8f166cc7f06"
+checksum = "139834ddba373bbdd213dffe02c8d110508dcf1726c2be27e8d1f7d7e1856418"
 dependencies = [
- "libc",
- "winapi",
+ "arrayvec",
+ "auto_impl",
+ "bytes",
 ]
 
 [[package]]
@@ -1908,14 +2623,14 @@ dependencies = [
 
 [[package]]
 name = "filetime"
-version = "0.2.23"
+version = "0.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.4.1",
- "windows-sys 0.52.0",
+ "libredox 0.1.3",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1938,9 +2653,9 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flate2"
-version = "1.0.30"
+version = "1.0.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -1952,24 +2667,31 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f81ec6369c545a7d40e4589b5597581fa1c441fe1cce96dd1de43159910a36a2"
+
 [[package]]
 name = "forc"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "annotate-snippets",
  "ansi_term",
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "clap_complete",
  "clap_complete_fig",
  "completest-pty",
  "forc-pkg",
  "forc-test",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
  "forc-util",
  "fs_extra",
  "fuel-asm",
  "hex",
+ "rexpect 0.5.0",
  "serde",
  "serde_json",
  "sway-core",
@@ -1979,8 +2701,8 @@ dependencies = [
  "sway-utils",
  "term-table",
  "tokio",
- "toml 0.7.8",
- "toml_edit 0.19.15",
+ "toml 0.8.19",
+ "toml_edit",
  "tracing",
  "url",
  "uwuify",
@@ -1990,16 +2712,19 @@ dependencies = [
 
 [[package]]
 name = "forc-client"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
  "async-trait",
+ "aws-config",
+ "aws-sdk-kms",
  "chrono",
- "clap 4.5.4",
+ "clap 4.5.20",
  "devault",
+ "dialoguer",
  "forc",
  "forc-pkg",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
  "forc-tx",
  "forc-util",
  "forc-wallet",
@@ -2009,63 +2734,77 @@ dependencies = [
  "fuel-crypto",
  "fuel-tx",
  "fuel-vm",
+ "fuels",
  "fuels-accounts",
  "fuels-core",
  "futures",
  "hex",
+ "k256",
+ "portpicker",
+ "pretty_assertions",
  "rand",
+ "regex",
+ "rexpect 0.5.0",
  "rpassword",
  "serde",
  "serde_json",
  "sway-core",
  "sway-types",
  "sway-utils",
+ "tempfile",
  "tokio",
+ "toml_edit",
  "tracing",
 ]
 
 [[package]]
 name = "forc-crypto"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
  "async-trait",
  "atty",
- "clap 4.5.4",
- "forc-tracing 0.60.0",
+ "clap 4.5.20",
+ "criterion",
+ "forc-tracing 0.66.2",
  "forc-util",
  "fuel-core-types",
  "fuel-crypto",
+ "fuels-accounts",
  "fuels-core",
  "futures",
  "hex",
  "libp2p-identity",
  "rand",
+ "rayon",
+ "regex",
  "serde",
  "serde_json",
  "serde_yaml",
  "sha3",
- "termion",
+ "tempfile",
+ "termion 4.0.3",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "forc-debug"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "dap",
  "escargot",
  "forc-pkg",
  "forc-test",
+ "forc-tracing 0.66.2",
  "fuel-core-client",
  "fuel-types",
  "fuel-vm",
  "portpicker",
  "rayon",
- "rexpect",
+ "rexpect 0.4.0",
  "serde",
  "serde_json",
  "shellfish",
@@ -2077,20 +2816,20 @@ dependencies = [
 
 [[package]]
 name = "forc-doc"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
- "colored",
+ "clap 4.5.20",
  "comrak",
  "dir_indexer",
  "expect-test",
  "forc-pkg",
+ "forc-tracing 0.66.2",
  "forc-util",
  "horrorshow",
  "include_dir",
  "minifier",
- "opener 0.5.2",
+ "opener",
  "serde",
  "serde_json",
  "sway-ast",
@@ -2102,14 +2841,14 @@ dependencies = [
 
 [[package]]
 name = "forc-fmt"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "forc-pkg",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
  "forc-util",
- "prettydiff 0.5.1",
+ "prettydiff 0.7.0",
  "sway-core",
  "sway-utils",
  "swayfmt",
@@ -2119,10 +2858,10 @@ dependencies = [
 
 [[package]]
 name = "forc-lsp"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "sway-lsp",
  "tikv-jemallocator",
  "tokio",
@@ -2130,12 +2869,13 @@ dependencies = [
 
 [[package]]
 name = "forc-pkg"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "ansi_term",
  "anyhow",
+ "byte-unit",
  "cid",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
  "forc-util",
  "fuel-abi-types",
  "futures",
@@ -2145,8 +2885,8 @@ dependencies = [
  "ipfs-api-backend-hyper",
  "petgraph",
  "regex",
- "reqwest",
- "semver",
+ "reqwest 0.12.8",
+ "semver 1.0.23",
  "serde",
  "serde_ignored",
  "serde_json",
@@ -2157,7 +2897,7 @@ dependencies = [
  "sway-utils",
  "sysinfo",
  "tar",
- "toml 0.7.8",
+ "toml 0.8.19",
  "tracing",
  "url",
  "vec1",
@@ -2166,7 +2906,7 @@ dependencies = [
 
 [[package]]
 name = "forc-test"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
  "forc-pkg",
@@ -2193,19 +2933,20 @@ dependencies = [
 
 [[package]]
 name = "forc-tracing"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "ansi_term",
  "tracing",
  "tracing-subscriber",
+ "tracing-test",
 ]
 
 [[package]]
 name = "forc-tx"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "devault",
  "forc-util",
  "fuel-tx",
@@ -2217,15 +2958,15 @@ dependencies = [
 
 [[package]]
 name = "forc-util"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "annotate-snippets",
  "ansi_term",
  "anyhow",
- "clap 4.5.4",
- "dirs 3.0.2",
- "fd-lock 4.0.2",
- "forc-tracing 0.60.0",
+ "clap 4.5.20",
+ "dirs 5.0.1",
+ "fd-lock",
+ "forc-tracing 0.66.2",
  "fuel-tx",
  "hex",
  "paste",
@@ -2244,12 +2985,12 @@ dependencies = [
 
 [[package]]
 name = "forc-wallet"
-version = "0.8.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "223adda9aca17455167e0bea681b31a7a5819c83b73978876424eafc4ee48611"
+checksum = "4e6ad4498ecab72fa7c5e134ade0137279d1b8f4a6df50963bb3803fdeb69dac"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "eth-keystore",
  "forc-tracing 0.47.0",
  "fuel-crypto",
@@ -2262,7 +3003,7 @@ dependencies = [
  "rand",
  "rpassword",
  "serde_json",
- "termion",
+ "termion 2.0.3",
  "tiny-bip39",
  "tokio",
  "url",
@@ -2309,9 +3050,9 @@ dependencies = [
 
 [[package]]
 name = "fuel-abi-types"
-version = "0.5.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0e7e87f94417ff1a5d60e496906033c58bfe5367546621f131fe8cdabaa2671"
+checksum = "bce44ac13b1971be7cea024a2003cf944522093dafec454fea9ff792f0ff2577"
 dependencies = [
  "itertools 0.10.5",
  "lazy_static",
@@ -2320,17 +3061,17 @@ dependencies = [
  "regex",
  "serde",
  "serde_json",
- "syn 2.0.65",
+ "syn 2.0.79",
  "thiserror",
 ]
 
 [[package]]
 name = "fuel-asm"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db81c0bdf07b052d1c595b5ee71e20f0286ca3dc88c7ab3f775e08c8e055c34f"
+checksum = "5f325971bf9047ec70004f80a989e03456316bc19cbef3ff3a39a38b192ab56e"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "fuel-types",
  "serde",
  "strum 0.24.1",
@@ -2338,9 +3079,9 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-chain-config"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16323762c4a5d58b11121580bee9f3a76ac7f655f95d727f957b05a9e35f477f"
+checksum = "990db3029efd3766c4ae7c92a53c159ae66abf6f568ac6a3d58354f11400e6e2"
 dependencies = [
  "anyhow",
  "bech32",
@@ -2358,20 +3099,21 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-client"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f33af785942254f23e30a03a08a08ffb8eea645a87f06895e5d84f4205fc191a"
+checksum = "f09b3a35e82226d77b10653829beb508dc4bcf698fbdaa96610faf894e794444"
 dependencies = [
  "anyhow",
+ "base64 0.22.1",
  "cynic",
- "derive_more",
+ "derive_more 0.99.18",
  "eventsource-client",
  "fuel-core-types",
  "futures",
  "hex",
  "hyper-rustls 0.24.2",
  "itertools 0.12.1",
- "reqwest",
+ "reqwest 0.11.27",
  "schemafy_lib",
  "serde",
  "serde_json",
@@ -2382,23 +3124,25 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-metrics"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a47f442a32f2e5917066bbf9be3d6fd5d85252a131f1b5fc2f2f0ee75008066"
+checksum = "94a1c3eb92040d95d27f7c658801bb5c04ad4aaf67de380cececbeed5aab6e61"
 dependencies = [
- "axum",
  "once_cell",
+ "parking_lot 0.12.3",
  "pin-project-lite",
  "prometheus-client",
  "regex",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
  "tracing",
 ]
 
 [[package]]
 name = "fuel-core-poa"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f6185f492f9ddb65228db0f250b3f6384637ebf76b72fc81b2efb629d887912"
+checksum = "2f6f78fa31dc56b9458e3ca9a7058b4bea381e16e49fcab0db49923be8a30f9c"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2406,6 +3150,8 @@ dependencies = [
  "fuel-core-services",
  "fuel-core-storage",
  "fuel-core-types",
+ "serde",
+ "serde_json",
  "tokio",
  "tokio-stream",
  "tracing",
@@ -2413,33 +3159,34 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-services"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d35200489fdcdafbe5a6a3a39baad4da523e5c004db9a885056be0137ee35098"
+checksum = "8312b598da4b9a6503c9263c1c2a7ea58d34ab1f86e7f345490e12d309fb29bb"
 dependencies = [
  "anyhow",
  "async-trait",
  "fuel-core-metrics",
  "futures",
- "parking_lot 0.12.2",
+ "parking_lot 0.12.3",
+ "pin-project-lite",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "fuel-core-storage"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4e85b634f42fb53193da517b4a2efa8ac73031cdab653029a5b1d3725572d"
+checksum = "bda9242ebc9e8ef3251b9eae85f4ce5cdb376348baa30925606f3ce602db7ec5"
 dependencies = [
  "anyhow",
- "derive_more",
+ "derive_more 0.99.18",
  "enum-iterator",
  "fuel-core-types",
  "fuel-vm",
  "impl-tools",
  "itertools 0.12.1",
- "num_enum 0.7.2",
+ "num_enum",
  "paste",
  "postcard",
  "primitive-types",
@@ -2450,28 +3197,27 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-types"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffe21004dd036f4c454666e339bd0fc3b037535bbc5510321db2565087edd4fc"
+checksum = "6ee3a95b189bf729d21354a761862bb481298cbd883550adc3fef1bc7beb0b67"
 dependencies = [
  "anyhow",
  "bs58",
  "derivative",
- "derive_more",
+ "derive_more 0.99.18",
  "fuel-vm",
  "rand",
  "secrecy",
  "serde",
  "tai64",
- "thiserror",
  "zeroize",
 ]
 
 [[package]]
 name = "fuel-crypto"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca73b3409086e772315625304cabd2eeec10e4bd1f8b8a99cc72e0aed755e5c"
+checksum = "65e318850ca64890ff123a99b6b866954ef49da94ab9bc6827cf6ee045568585"
 dependencies = [
  "coins-bip32",
  "coins-bip39",
@@ -2482,7 +3228,7 @@ dependencies = [
  "lazy_static",
  "p256",
  "rand",
- "secp256k1 0.26.0",
+ "secp256k1",
  "serde",
  "sha2 0.10.8",
  "zeroize",
@@ -2490,13 +3236,13 @@ dependencies = [
 
 [[package]]
 name = "fuel-derive"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8d6e66d1b68eb916640c12a1c6c40880e11fcf569359b04483d5e18237c5229"
+checksum = "ab0bc46a3552964bae5169e79b383761a54bd115ea66951a1a7a229edcefa55a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
  "synstructure 0.13.1",
 ]
 
@@ -2549,11 +3295,11 @@ dependencies = [
 
 [[package]]
 name = "fuel-merkle"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "faa4b60ddfa51b64d02a1d71b0cf51488171d313b32ae3fb9f39f64ddd21791b"
+checksum = "c79eca6a452311c70978a5df796c0f99f27e474b69719e0db4c1d82e68800d07"
 dependencies = [
- "derive_more",
+ "derive_more 0.99.18",
  "digest 0.10.7",
  "fuel-storage",
  "hashbrown 0.13.2",
@@ -2564,19 +3310,19 @@ dependencies = [
 
 [[package]]
 name = "fuel-storage"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beef5f12c40118e87ef6abf611c6bba5c88754e727fb825120ae7d0872123055"
+checksum = "2d0c46b5d76b3e11197bd31e036cd8b1cb46c4d822cacc48836638080c6d2b76"
 
 [[package]]
 name = "fuel-tx"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95857e761db34a50967f53af7a74be08130d210bd985c5585f36bd753d346c"
+checksum = "6723bb8710ba2b70516ac94d34459593225870c937670fb3afaf82e0354667ac"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "derivative",
- "derive_more",
+ "derive_more 0.99.18",
  "fuel-asm",
  "fuel-crypto",
  "fuel-merkle",
@@ -2586,16 +3332,15 @@ dependencies = [
  "postcard",
  "rand",
  "serde",
- "serde_json",
  "strum 0.24.1",
  "strum_macros 0.24.3",
 ]
 
 [[package]]
 name = "fuel-types"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0af9f9d8c9eb3f4e644731c829ee7da5c3cae0886864731089627af25e336cea"
+checksum = "982265415a99b5bd6277bc24194a233bb2e18764df11c937b3dbb11a02c9e545"
 dependencies = [
  "fuel-derive",
  "hex",
@@ -2605,16 +3350,16 @@ dependencies = [
 
 [[package]]
 name = "fuel-vm"
-version = "0.50.0"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71df1a9ede5237febbc7864888f26365814327732ccd11002e9bddac1ce9a4e6"
+checksum = "54b5362d7d072c72eec20581f67fc5400090c356a7f3ae77c79880b3b177b667"
 dependencies = [
  "anyhow",
  "async-trait",
  "backtrace",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "derivative",
- "derive_more",
+ "derive_more 0.99.18",
  "ethnum",
  "fuel-asm",
  "fuel-crypto",
@@ -2639,9 +3384,9 @@ dependencies = [
 
 [[package]]
 name = "fuels"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e318b107e6fef3d786f2366cc78a6314a6b326342d375203238f130a7356fe49"
+checksum = "6ed08053e72bdb285d5a167c27a7a0d10f1dc4e27d1e6e5296dd2a67813bd13f"
 dependencies = [
  "fuel-core-client",
  "fuel-crypto",
@@ -2655,12 +3400,13 @@ dependencies = [
 
 [[package]]
 name = "fuels-accounts"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e17d23b925d3d5e21dc5428330695c596db356d4adfc90eadecc2a490d7d5ce"
+checksum = "49fee90e8f3a4fc9392a6cde3010c561fa50da0f805d66fdb659eaa4d5d8a504"
 dependencies = [
  "async-trait",
  "chrono",
+ "cynic",
  "elliptic-curve",
  "eth-keystore",
  "fuel-core-client",
@@ -2669,8 +3415,9 @@ dependencies = [
  "fuel-tx",
  "fuel-types",
  "fuels-core",
+ "itertools 0.12.1",
  "rand",
- "semver",
+ "semver 1.0.23",
  "tai64",
  "thiserror",
  "tokio",
@@ -2679,9 +3426,9 @@ dependencies = [
 
 [[package]]
 name = "fuels-code-gen"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86a7a5b4811f5563bb5c2485efc7653ed6ce465c452a1182ae9062aa13dd19af"
+checksum = "f857b7ff658400506ca6be57bb84fedda44b566e78f5f0a8d0782242f41615c0"
 dependencies = [
  "Inflector",
  "fuel-abi-types",
@@ -2690,14 +3437,14 @@ dependencies = [
  "quote",
  "regex",
  "serde_json",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "fuels-core"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9774ae9b35f808fa18b92d0478a3b0acbea41011409efa3117f972dfe528ae09"
+checksum = "baccbdd81e624f57950dcb136b32b853c520dd954badf26b9f58de33f3d71c7e"
 dependencies = [
  "async-trait",
  "bech32",
@@ -2717,28 +3464,29 @@ dependencies = [
  "postcard",
  "serde",
  "serde_json",
+ "sha2 0.10.8",
  "thiserror",
  "uint",
 ]
 
 [[package]]
 name = "fuels-macros"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba92a701fa86eed843db68d991807207b8b3d47099d49fb82467e8900f680e01"
+checksum = "5da75294c5e9da312bdc49239736699ee84ea9c5bfbc19a61a8ee588a1247aa1"
 dependencies = [
  "fuels-code-gen",
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "fuels-programs"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6c72ac2f1cdda800dbc1c3714459f83bf208cef78812448992b6dbdda6841dc"
+checksum = "32675ed1c08edd28ddb648dfae0c60a1946d4368a69ddfa6434f2316e33f0520"
 dependencies = [
  "async-trait",
  "fuel-abi-types",
@@ -2755,9 +3503,9 @@ dependencies = [
 
 [[package]]
 name = "fuels-test-helpers"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b8a632f2b4ddb52e8ad92871f63521e9f5cc299f842a3207f3655acc21c148"
+checksum = "02176c0fb1bf8cf58b8a9e5372efb650324740abcd4847b45bd0b041a0f133a2"
 dependencies = [
  "fuel-core-chain-config",
  "fuel-core-client",
@@ -2785,9 +3533,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -2800,9 +3548,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -2810,15 +3558,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -2827,38 +3575,38 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
 
 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -2893,17 +3641,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "getrandom"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
 [[package]]
 name = "getrandom"
 version = "0.2.15"
@@ -2912,27 +3649,27 @@ checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.28.1"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
 dependencies = [
  "fallible-iterator",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "git2"
-version = "0.17.2"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b989d6a7ca95a362cf2cfc5ad688b3a467be1f87e480b8dad07fee8c79b0044"
+checksum = "b903b73e45dc0c6c596f2d37eccece7c1c8bb6e4407b001096387c63d0d93724"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "libc",
  "libgit2-sys",
  "log",
@@ -2943,39 +3680,49 @@ dependencies = [
 
 [[package]]
 name = "gix-features"
-version = "0.28.1"
+version = "0.38.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b76f9a80f6dd7be66442ae86e1f534effad9546676a392acc95e269d0c21c22"
+checksum = "ac7045ac9fe5f9c727f38799d002a7ed3583cd777e3322a7c4b43e3cf437dc69"
 dependencies = [
  "gix-hash",
+ "gix-trace",
  "libc",
 ]
 
 [[package]]
 name = "gix-hash"
-version = "0.10.4"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a258595457bc192d1f1c59d0d168a1e34e2be9b97a614e14995416185de41a7"
+checksum = "f93d7df7366121b5018f947a04d37f034717e113dcf9ccd85c34b58e57a74d5e"
 dependencies = [
- "hex",
+ "faster-hex",
  "thiserror",
 ]
 
 [[package]]
 name = "gix-path"
-version = "0.7.3"
+version = "0.10.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32370dce200bb951df013e03dff35b4233fc7a89458642b047629b91734a7e19"
+checksum = "ebfc4febd088abdcbc9f1246896e57e37b7a34f6909840045a1767c6dafac7af"
 dependencies = [
  "bstr",
+ "gix-trace",
+ "home",
+ "once_cell",
  "thiserror",
 ]
 
+[[package]]
+name = "gix-trace"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cae0e8661c3ff92688ce1c8b8058b3efb312aba9492bbe93661a21705ab431b"
+
 [[package]]
 name = "gix-url"
-version = "0.16.0"
+version = "0.27.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6a22b4b32ad14d68f7b7fb6458fa58d44b01797d94c1b8f4db2d9c7b3c366b5"
+checksum = "fd280c5e84fb22e128ed2a053a0daeacb6379469be6a85e3d518a0636e160c89"
 dependencies = [
  "bstr",
  "gix-features",
@@ -2992,13 +3739,26 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
+[[package]]
+name = "globset"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15f1ce686646e7f1e19bf7d5533fe443a45dbfb990e00629110797578b42fb19"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata 0.4.8",
+ "regex-syntax 0.8.5",
+]
+
 [[package]]
 name = "graph-cycles"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a6ad932c6dd3cfaf16b66754a42f87bbeefd591530c4b6a8334270a7df3e853"
 dependencies = [
- "ahash",
+ "ahash 0.8.11",
  "petgraph",
  "thiserror",
 ]
@@ -3035,8 +3795,27 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "futures-util",
- "http",
- "indexmap 2.2.6",
+ "http 0.2.12",
+ "indexmap 2.6.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http 1.1.0",
+ "indexmap 2.6.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -3076,17 +3855,14 @@ dependencies = [
  "byteorder",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.8",
+]
 
 [[package]]
 name = "hashbrown"
@@ -3094,7 +3870,7 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
 dependencies = [
- "ahash",
+ "ahash 0.8.11",
 ]
 
 [[package]]
@@ -3103,11 +3879,20 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
- "ahash",
+ "ahash 0.8.11",
  "allocator-api2",
  "serde",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
+dependencies = [
+ "foldhash",
+]
+
 [[package]]
 name = "heapless"
 version = "0.7.17"
@@ -3116,9 +3901,9 @@ checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
 dependencies = [
  "atomic-polyfill",
  "hash32",
- "rustc_version",
+ "rustc_version 0.4.1",
  "serde",
- "spin 0.9.8",
+ "spin",
  "stable_deref_trait",
 ]
 
@@ -3158,11 +3943,26 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
+[[package]]
+name = "hermit-abi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+
 [[package]]
 name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "hex-literal"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
 
 [[package]]
 name = "hkdf"
@@ -3229,6 +4029,17 @@ dependencies = [
  "itoa",
 ]
 
+[[package]]
+name = "http"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
 [[package]]
 name = "http-body"
 version = "0.4.6"
@@ -3236,21 +4047,38 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
  "bytes",
- "http",
+ "http 0.2.12",
  "pin-project-lite",
 ]
 
 [[package]]
-name = "http-range-header"
-version = "0.3.1"
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http 1.1.0",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f"
+checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
+dependencies = [
+ "bytes",
+ "futures-util",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "pin-project-lite",
+]
 
 [[package]]
 name = "httparse"
-version = "1.8.0"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+checksum = "7d71d3574edd2771538b901e6549113b4006ece66150fb69c0fb6d9a2adae946"
 
 [[package]]
 name = "httpdate"
@@ -3266,17 +4094,17 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "hyper"
-version = "0.14.28"
+version = "0.14.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
+checksum = "8c08302e8fa335b151b788c775ff56e7a03ae64ff85c548ee820fecb70356e85"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
- "http",
- "http-body",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
  "httparse",
  "httpdate",
  "itoa",
@@ -3288,6 +4116,26 @@ dependencies = [
  "want",
 ]
 
+[[package]]
+name = "hyper"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbff0a806a4728c99295b254c8838933b5b082d75e3cb70c8dab21fdfbcfa9a"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "h2 0.4.6",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
 [[package]]
 name = "hyper-multipart-rfc7578"
 version = "0.8.0"
@@ -3297,42 +4145,42 @@ dependencies = [
  "bytes",
  "common-multipart-rfc7578",
  "futures-core",
- "http",
- "hyper",
+ "http 0.2.12",
+ "hyper 0.14.31",
 ]
 
 [[package]]
 name = "hyper-rustls"
-version = "0.22.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f9f7a97316d44c0af9b0301e65010573a853a9fc97046d7331d7f6bc0fd5a64"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
- "ct-logs",
  "futures-util",
- "hyper",
+ "http 0.2.12",
+ "hyper 0.14.31",
  "log",
- "rustls 0.19.1",
- "rustls-native-certs 0.5.0",
+ "rustls 0.21.12",
+ "rustls-native-certs",
  "tokio",
- "tokio-rustls 0.22.0",
- "webpki",
+ "tokio-rustls 0.24.1",
+ "webpki-roots",
 ]
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.2"
+version = "0.27.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333"
 dependencies = [
  "futures-util",
- "http",
- "hyper",
- "log",
- "rustls 0.21.12",
- "rustls-native-certs 0.6.3",
+ "http 1.1.0",
+ "hyper 1.5.0",
+ "hyper-util",
+ "rustls 0.23.15",
+ "rustls-pki-types",
  "tokio",
- "tokio-rustls 0.24.1",
- "webpki-roots",
+ "tokio-rustls 0.26.0",
+ "tower-service",
 ]
 
 [[package]]
@@ -3341,7 +4189,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1"
 dependencies = [
- "hyper",
+ "hyper 0.14.31",
  "pin-project-lite",
  "tokio",
  "tokio-io-timeout",
@@ -3349,22 +4197,44 @@ dependencies = [
 
 [[package]]
 name = "hyper-tls"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
 dependencies = [
  "bytes",
- "hyper",
+ "http-body-util",
+ "hyper 1.5.0",
+ "hyper-util",
  "native-tls",
  "tokio",
  "tokio-native-tls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41296eb09f183ac68eec06e03cdbea2e759633d4067b2f6552fc2e009bcad08b"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "hyper 1.5.0",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -3459,7 +4329,7 @@ dependencies = [
  "autocfg",
  "impl-tools-lib",
  "proc-macro-error",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -3471,7 +4341,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -3493,18 +4363,18 @@ checksum = "b5bd47a3c8188d842aa7ff4dd65a9732f740fcbe04689ecfbfef43c465b381de"
 
 [[package]]
 name = "include_dir"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18762faeff7122e89e0857b02f7ce6fcc0d101d5e9ad2ad7846cc01d61b7f19e"
+checksum = "923d117408f1e49d914f1a379a309cffe4f18c05cf4e3d12e613a15fc81bd0dd"
 dependencies = [
  "include_dir_macros",
 ]
 
 [[package]]
 name = "include_dir_macros"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b139284b5cf57ecfa712bcc66950bb635b31aff41c188e8a4cfc758eca374a3f"
+checksum = "7cab85a7ed0bd5f0e76d93846e0147172bed2e2d3f859bcc33a8d9699cad1a75"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3523,16 +4393,22 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.0",
  "rayon",
  "serde",
 ]
 
+[[package]]
+name = "indoc"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+
 [[package]]
 name = "inotify"
 version = "0.9.6"
@@ -3564,9 +4440,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.39.0"
+version = "1.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810ae6042d48e2c9e9215043563a58a80b877bc863228a74cf10c49d4620a6f5"
+checksum = "6593a41c7a73841868772495db7dc1e8ecab43bb5c0b6da2059246c4b506ab60"
 dependencies = [
  "console",
  "lazy_static",
@@ -3595,8 +4471,8 @@ dependencies = [
  "base64 0.13.1",
  "bytes",
  "futures",
- "http",
- "hyper",
+ "http 0.2.12",
+ "hyper 0.14.31",
  "hyper-multipart-rfc7578",
  "ipfs-api-prelude",
  "thiserror",
@@ -3614,7 +4490,7 @@ dependencies = [
  "common-multipart-rfc7578",
  "dirs 4.0.0",
  "futures",
- "http",
+ "http 0.2.12",
  "multiaddr",
  "multibase",
  "serde",
@@ -3630,26 +4506,26 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.9.0"
+version = "2.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+checksum = "ddc24109865250148c2e0f3d25d4f0f479571723792d3802153c60922a4fb708"
 
 [[package]]
 name = "is-terminal"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
 dependencies = [
- "hermit-abi 0.3.9",
+ "hermit-abi 0.4.0",
  "libc",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
 [[package]]
 name = "itertools"
@@ -3678,6 +4554,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
@@ -3686,27 +4571,27 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jobserver"
-version = "0.1.31"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "6a88f1bda2bd75b0452a14784937d796722fdebfe50df998aeb3f0b7603019a9"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "k256"
-version = "0.13.3"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
 dependencies = [
  "cfg-if 1.0.0",
  "ecdsa",
@@ -3725,6 +4610,16 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "keccak-asm"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6"
+dependencies = [
+ "digest 0.10.7",
+ "sha3-asm",
+]
+
 [[package]]
 name = "kqueue"
 version = "1.0.8"
@@ -3747,18 +4642,18 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin 0.5.2",
+ "spin",
 ]
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.161"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
 
 [[package]]
 name = "libdbus-sys"
@@ -3772,9 +4667,9 @@ dependencies = [
 
 [[package]]
 name = "libgit2-sys"
-version = "0.15.2+1.6.4"
+version = "0.17.0+1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a80df2e11fb4a61f4ba2ab42dbe7f74468da143f1a75c74e11dee7c813f694fa"
+checksum = "10472326a8a6477c3c20a64547b0059e4b0d086869eee31e6d7da728a8eb7224"
 dependencies = [
  "cc",
  "libc",
@@ -3792,9 +4687,9 @@ checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
 
 [[package]]
 name = "libp2p-identity"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "999ec70441b2fb35355076726a6bc466c932e9bdc66f6a11c6c0aa17c7ab9be0"
+checksum = "55cca1eb2bc1fd29f099f3daaab7effd01e1a54b7c577d0ed082521034d912e8"
 dependencies = [
  "asn1_der",
  "bs58",
@@ -3814,7 +4709,7 @@ version = "0.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
  "redox_syscall 0.4.1",
 ]
@@ -3825,8 +4720,9 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
+ "redox_syscall 0.5.7",
 ]
 
 [[package]]
@@ -3891,11 +4787,23 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "libtest-mimic"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc0bda45ed5b3a2904262c1bb91e526127aa70e7ef3758aba2ef93cf896b9b58"
+dependencies = [
+ "clap 4.5.20",
+ "escape8259",
+ "termcolor",
+ "threadpool",
+]
+
 [[package]]
 name = "libz-sys"
-version = "1.1.16"
+version = "1.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e143b5e666b2695d28f6bca6497720813f699c9602dd7f5cac91008b8ada7f9"
+checksum = "d2d16453e800a8cf6dd2fc3eb4bc99b786a9b90c663b8559a5b1a041bf89e472"
 dependencies = [
  "cc",
  "libc",
@@ -3903,12 +4811,6 @@ dependencies = [
  "vcpkg",
 ]
 
-[[package]]
-name = "line-wrap"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd1bc4d24ad230d21fb898d1116b1801d7adfc449d42026475862ab48b11e70e"
-
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -3933,9 +4835,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "logos"
@@ -3982,12 +4884,6 @@ dependencies = [
  "regex-automata 0.1.10",
 ]
 
-[[package]]
-name = "matchit"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73cbba799671b762df5a175adf59ce145165747bb891505c43d09aefbbf38beb"
-
 [[package]]
 name = "mdbook"
 version = "0.4.40"
@@ -3996,14 +4892,14 @@ checksum = "b45a38e19bd200220ef07c892b0157ad3d2365e5b5a267ca01ad12182491eea5"
 dependencies = [
  "anyhow",
  "chrono",
- "clap 4.5.4",
+ "clap 4.5.20",
  "clap_complete",
  "env_logger",
  "handlebars",
  "log",
  "memchr",
  "once_cell",
- "opener 0.7.1",
+ "opener",
  "pulldown-cmark",
  "regex",
  "serde",
@@ -4019,18 +4915,18 @@ name = "mdbook-forc-documenter"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "clap 4.5.4",
+ "clap 4.5.20",
  "mdbook",
- "semver",
+ "semver 1.0.23",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.7.2"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memoffset"
@@ -4050,100 +4946,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "miden"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8d8a25e092075f58af207e2a42bad5fbbf40c5200f13d2432a806db751a52b5"
-dependencies = [
- "log",
- "miden-air",
- "miden-assembly",
- "miden-core",
- "miden-processor",
- "miden-prover",
- "miden-stdlib",
- "miden-verifier",
-]
-
-[[package]]
-name = "miden-air"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5046ab97d8c2b7136601e9430fd0a14e7d6c6cdd648c90c1e6b39186a38b9a8b"
-dependencies = [
- "miden-core",
- "winter-air",
-]
-
-[[package]]
-name = "miden-assembly"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a04eec160cbd5cf3051ad16a244c3d83e648eddbd3349120dc069f6e309259dc"
-dependencies = [
- "miden-core",
- "num_enum 0.5.11",
- "winter-crypto",
-]
-
-[[package]]
-name = "miden-core"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e75a2446684f44e61afb27bbdbf2458e8ec58c5c55d9bd202981d7cd265f7cf4"
-dependencies = [
- "winter-crypto",
- "winter-math",
- "winter-utils",
-]
-
-[[package]]
-name = "miden-processor"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb7a467447a7d6236f3971f91f8c47c8880a01a43c29b0b08285ec50454f02ed"
-dependencies = [
- "log",
- "miden-core",
- "winter-prover",
-]
-
-[[package]]
-name = "miden-prover"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2343eaf338770b78fe421f36a3445bb491123e0787006dfa2b98788cd6440ec6"
-dependencies = [
- "log",
- "miden-air",
- "miden-core",
- "miden-processor",
- "winter-prover",
-]
-
-[[package]]
-name = "miden-stdlib"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b2a52fd1a44b136dbce7a513ebe5a407dfebc17160af8a2707383df731fc098"
-dependencies = [
- "miden-assembly",
- "miden-core",
-]
-
-[[package]]
-name = "miden-verifier"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d942d5b0bdcad47359d52534ef6fbccebffc0c713d2c7ca65ab603c7965c0a8b"
-dependencies = [
- "miden-air",
- "miden-assembly",
- "miden-core",
- "winter-verifier",
-]
-
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -4152,9 +4954,9 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "mime_guess"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
 dependencies = [
  "mime",
  "unicase",
@@ -4162,17 +4964,20 @@ dependencies = [
 
 [[package]]
 name = "minifier"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95bbbf96b9ac3482c2a25450b67a15ed851319bc5fabf3b40742ea9066e84282"
+checksum = "9aa3f302fe0f8de065d4a2d1ed64f60204623cac58b80cd3c2a83a25d5a7d437"
+dependencies = [
+ "clap 4.5.20",
+]
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87dfd01fe195c66b572b37921ad8803d010623c0aca821bea2302239d155cdae"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
 dependencies = [
- "adler",
+ "adler2",
 ]
 
 [[package]]
@@ -4183,10 +4988,22 @@ checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
 dependencies = [
  "libc",
  "log",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi",
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "mio"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+dependencies = [
+ "hermit-abi 0.3.9",
+ "libc",
+ "wasi",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "multiaddr"
 version = "0.17.1"
@@ -4202,7 +5019,7 @@ dependencies = [
  "percent-encoding",
  "serde",
  "static_assertions",
- "unsigned-varint",
+ "unsigned-varint 0.7.2",
  "url",
 ]
 
@@ -4225,24 +5042,7 @@ checksum = "835d6ff01d610179fbce3de1694d007e500bf33a7f29689838941d6bf783ae40"
 dependencies = [
  "core2",
  "multihash-derive",
- "unsigned-varint",
-]
-
-[[package]]
-name = "multihash"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfd8a792c1694c6da4f68db0a9d707c72bd260994da179e6030a5dcee00bb815"
-dependencies = [
- "blake2b_simd 1.0.2",
- "blake2s_simd",
- "blake3",
- "core2",
- "digest 0.10.7",
- "multihash-derive",
- "sha2 0.10.8",
- "sha3",
- "unsigned-varint",
+ "unsigned-varint 0.7.2",
 ]
 
 [[package]]
@@ -4252,7 +5052,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "076d548d76a0e2a0d4ab471d0b1c36c577786dfc4471242035d97a12a735c492"
 dependencies = [
  "core2",
- "unsigned-varint",
+ "unsigned-varint 0.7.2",
 ]
 
 [[package]]
@@ -4271,11 +5071,10 @@ dependencies = [
 
 [[package]]
 name = "native-tls"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
+checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
 dependencies = [
- "lazy_static",
  "libc",
  "log",
  "openssl",
@@ -4311,14 +5110,16 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.20.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa9b4819da1bc61c0ea48b63b7bc8604064dd43013e7cc325df098d49cd7c18a"
+checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
 dependencies = [
+ "autocfg",
  "bitflags 1.3.2",
- "cc",
  "cfg-if 1.0.0",
  "libc",
+ "memoffset 0.6.5",
+ "pin-utils",
 ]
 
 [[package]]
@@ -4334,40 +5135,59 @@ dependencies = [
  "pin-utils",
 ]
 
+[[package]]
+name = "nix"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
+dependencies = [
+ "bitflags 2.6.0",
+ "cfg-if 1.0.0",
+ "libc",
+]
+
+[[package]]
+name = "normalize-path"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5438dd2b2ff4c6df6e1ce22d825ed2fa93ee2922235cc45186991717f0a892d"
+
 [[package]]
 name = "normpath"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5831952a9476f2fed74b77d74182fa5ddc4d21c72ec45a333b250e3ed0272804"
+checksum = "c8911957c4b1549ac0dc74e30db9c8b0e66ddcd6d7acc33098f4c63a64a6d7ed"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "notify"
-version = "5.2.0"
+version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "729f63e1ca555a43fe3efa4f3efdf4801c479da85b432242a7b726f353c88486"
+checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
  "inotify",
  "kqueue",
  "libc",
- "mio",
+ "log",
+ "mio 0.8.11",
  "walkdir",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "notify-debouncer-mini"
-version = "0.2.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e23e9fa24f094b143c1eb61f90ac6457de87be6987bc70746e0179f7dbc9007b"
+checksum = "5d40b221972a1fc5ef4d858a2f671fb34c75983eb385463dff3780eeff6a9d43"
 dependencies = [
  "crossbeam-channel",
+ "log",
  "notify",
 ]
 
@@ -4406,9 +5226,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
  "num-integer",
  "num-traits",
@@ -4468,6 +5288,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
+ "libm",
 ]
 
 [[package]]
@@ -4482,71 +5303,56 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
-dependencies = [
- "num_enum_derive 0.5.11",
-]
-
-[[package]]
-name = "num_enum"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02339744ee7253741199f897151b38e72257d13802d4ee837285cc2990a90845"
+checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
 dependencies = [
- "num_enum_derive 0.7.2",
+ "num_enum_derive",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.5.11"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
+checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
 dependencies = [
- "proc-macro-crate 1.1.3",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.79",
 ]
 
 [[package]]
-name = "num_enum_derive"
-version = "0.7.2"
+name = "numtoa"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
-dependencies = [
- "proc-macro-crate 3.1.0",
- "proc-macro2",
- "quote",
- "syn 2.0.65",
-]
+checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
 
 [[package]]
 name = "numtoa"
-version = "0.1.0"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
+checksum = "6aa2c4e539b869820a2b82e1aef6ff40aa85e65decdd5185e83fb4b1249cd00f"
 
 [[package]]
 name = "object"
-version = "0.32.2"
+version = "0.36.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "aedf0a2d09c573ed1d8d85b30c119153926a2b36dce0ab28322c09a117a4683e"
 dependencies = [
  "crc32fast",
  "flate2",
- "hashbrown 0.14.5",
- "indexmap 2.2.6",
+ "hashbrown 0.15.0",
+ "indexmap 2.6.0",
  "memchr",
  "ruzstd",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
 [[package]]
 name = "onig"
@@ -4572,9 +5378,9 @@ dependencies = [
 
 [[package]]
 name = "oorandom"
-version = "11.1.3"
+version = "11.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"
 
 [[package]]
 name = "opaque-debug"
@@ -4584,33 +5390,23 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "opener"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "293c15678e37254c15bd2f092314abb4e51d7fdde05c2021279c12631b54f005"
-dependencies = [
- "bstr",
- "winapi",
-]
-
-[[package]]
-name = "opener"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8df34be653210fbe9ffaff41d3b92721c56ce82dfee58ee684f9afb5e3a90c0"
+checksum = "d0812e5e4df08da354c851a3376fead46db31c2214f849d3de356d774d057681"
 dependencies = [
  "bstr",
  "dbus",
  "normpath",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "openssl"
-version = "0.10.64"
+version = "0.10.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
+checksum = "6174bc48f102d208783c2c84bf931bb75927a617866870de8a4ea85597f871f5"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cfg-if 1.0.0",
  "foreign-types",
  "libc",
@@ -4627,7 +5423,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -4638,18 +5434,18 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-src"
-version = "300.3.0+3.3.0"
+version = "300.3.2+3.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eba8804a1c5765b18c4b3f907e6897ebabeedebc9830e1a0046c4a4cf44663e1"
+checksum = "a211a18d945ef7e648cc6e0058f4c548ee46aab922ea203e0d30e966ea23647b"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.102"
+version = "0.9.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
+checksum = "45abf306cbf99debc8195b66b7346498d7b10c210de50418b5ccd7ceba08c741"
 dependencies = [
  "cc",
  "libc",
@@ -4658,6 +5454,28 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "os_pipe"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ffd2b0a5634335b135d5728d84c5e0fd726954b87111f7506a61c502280d982"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "outref"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4030760ffd992bef45b0ae3f10ce1aba99e33464c90d14dd7c039884963ddc7a"
+
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -4670,6 +5488,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2386b4ebe91c2f7f51082d4cefa145d030e33a1842a96b12e4885cc3c01f7a55"
 
+[[package]]
+name = "owo-colors"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"
+
 [[package]]
 name = "p256"
 version = "0.13.2"
@@ -4697,7 +5521,7 @@ version = "3.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "306800abfa29c7f16596b5970a588435e3d5b3149683d00c12b699cc19f895ee"
 dependencies = [
- "arrayvec 0.7.4",
+ "arrayvec",
  "bitvec",
  "byte-slice-cast",
  "impl-trait-for-tuples",
@@ -4711,7 +5535,7 @@ version = "3.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c"
 dependencies = [
- "proc-macro-crate 3.1.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
  "syn 1.0.109",
@@ -4730,9 +5554,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
 dependencies = [
  "lock_api",
  "parking_lot_core 0.9.10",
@@ -4760,9 +5584,9 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.5.1",
+ "redox_syscall 0.5.7",
  "smallvec",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -4792,9 +5616,9 @@ dependencies = [
 
 [[package]]
 name = "peg"
-version = "0.7.0"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07c0b841ea54f523f7aa556956fbd293bcbe06f2e67d2eb732b7278aaf1d166a"
+checksum = "295283b02df346d1ef66052a757869b2876ac29a6bb0ac3f5f7cd44aebe40e8f"
 dependencies = [
  "peg-macros",
  "peg-runtime",
@@ -4802,9 +5626,9 @@ dependencies = [
 
 [[package]]
 name = "peg-macros"
-version = "0.7.0"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5aa52829b8decbef693af90202711348ab001456803ba2a98eb4ec8fb70844c"
+checksum = "bdad6a1d9cf116a059582ce415d5f5566aabcd4008646779dab7fdc2a9a9d426"
 dependencies = [
  "peg-runtime",
  "proc-macro2",
@@ -4813,9 +5637,9 @@ dependencies = [
 
 [[package]]
 name = "peg-runtime"
-version = "0.7.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c719dcf55f09a3a7e764c6649ab594c18a177e3599c467983cdf644bfc0a4088"
+checksum = "e3aeb8f54c078314c2065ee649a7241f46b9d8e418e1a9581ba0546657d7aa3a"
 
 [[package]]
 name = "percent-encoding"
@@ -4825,9 +5649,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.7.10"
+version = "2.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
+checksum = "879952a81a83930934cbf1786752d6dedc3b1f29e8f8fb2ad1d0a36f377cf442"
 dependencies = [
  "memchr",
  "thiserror",
@@ -4836,9 +5660,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.7.10"
+version = "2.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26293c9193fbca7b1a3bf9b79dc1e388e927e6cacaa78b4a3ab705a1d3d41459"
+checksum = "d214365f632b123a47fd913301e14c946c61d1c183ee245fa76eb752e59a02dd"
 dependencies = [
  "pest",
  "pest_generator",
@@ -4846,22 +5670,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.10"
+version = "2.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ec22af7d3fb470a85dd2ca96b7c577a1eb4ef6f1683a9fe9a8c16e136c04687"
+checksum = "eb55586734301717aea2ac313f50b2eb8f60d2fc3dc01d190eefa2e625f60c4e"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.10"
+version = "2.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a240022f37c361ec1878d646fc5b7d7c4d28d5946e1a80ad5a7a4f4ca0bdcd"
+checksum = "b75da2a70cf4d9cb76833c990ac9cd3923c9a8905a8929789ce347c84564d03d"
 dependencies = [
  "once_cell",
  "pest",
@@ -4875,27 +5699,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "serde",
  "serde_derive",
 ]
 
 [[package]]
 name = "phf"
-version = "0.10.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
+checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
 dependencies = [
  "phf_macros",
  "phf_shared",
- "proc-macro-hack",
 ]
 
 [[package]]
 name = "phf_generator"
-version = "0.10.0"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
 dependencies = [
  "phf_shared",
  "rand",
@@ -4903,45 +5726,44 @@ dependencies = [
 
 [[package]]
 name = "phf_macros"
-version = "0.10.0"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58fdf3184dd560f160dd73922bea2d5cd6e8f064bf4b13110abd81b03697b4e0"
+checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
 dependencies = [
  "phf_generator",
  "phf_shared",
- "proc-macro-hack",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "phf_shared"
-version = "0.10.0"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
 dependencies = [
  "siphasher",
 ]
 
 [[package]]
 name = "pin-project"
-version = "1.1.5"
+version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+checksum = "baf123a161dde1e524adf36f90bc5d8d3462824a9c43553ad07a8183161189ec"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.5"
+version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+checksum = "a4502d8515ca9f32f1fb543d987f63d95a14934883db45bdb48060b6b69257f8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -4968,25 +5790,18 @@ dependencies = [
 
 [[package]]
 name = "pkg-config"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
-
-[[package]]
-name = "platforms"
-version = "3.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db23d408679286588f4d4644f965003d056e3dd5abcaaa938116871d7ce2fee7"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "plist"
-version = "1.6.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9d34169e64b3c7a80c8621a48adaf44e0cf62c78a9b25dd9dd35f1881a17cf9"
+checksum = "42cf17e9a1800f5f396bc67d193dc9411b59012a5876445ef450d449881e1016"
 dependencies = [
- "base64 0.21.7",
- "indexmap 2.2.6",
- "line-wrap",
+ "base64 0.22.1",
+ "indexmap 2.6.0",
  "quick-xml",
  "serde",
  "time",
@@ -4994,9 +5809,9 @@ dependencies = [
 
 [[package]]
 name = "plotters"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -5007,15 +5822,15 @@ dependencies = [
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81b30686a7d9c3e010b84284bdd26a29f2138574f52f5eb6f794fc0ad924e705"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
 dependencies = [
  "plotters-backend",
 ]
@@ -5031,12 +5846,13 @@ dependencies = [
 
 [[package]]
 name = "postcard"
-version = "1.0.8"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a55c51ee6c0db07e68448e336cf8ea4131a620edefebf9893e759b2d793420f8"
+checksum = "5f7f0a8d620d71c457dd1d47df76bb18960378da56af4527aaa10f515eee732e"
 dependencies = [
  "cobs",
- "embedded-io",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
  "heapless",
  "serde",
 ]
@@ -5049,29 +5865,21 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
-
-[[package]]
-name = "pretty_assertions"
-version = "1.4.0"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "diff",
- "yansi",
+ "zerocopy",
 ]
 
 [[package]]
-name = "prettydiff"
-version = "0.5.1"
+name = "pretty_assertions"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5671a83709b2755fe5b776d4915701bf36ed2cd9575035502ec12818141d71"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
 dependencies = [
- "ansi_term",
- "prettytable-rs 0.8.0",
- "structopt",
+ "diff",
+ "yansi 1.0.1",
 ]
 
 [[package]]
@@ -5082,22 +5890,19 @@ checksum = "8ff1fec61082821f8236cf6c0c14e8172b62ce8a72a0eedc30d3b247bb68dc11"
 dependencies = [
  "ansi_term",
  "pad",
- "prettytable-rs 0.10.0",
+ "prettytable-rs",
  "structopt",
 ]
 
 [[package]]
-name = "prettytable-rs"
-version = "0.8.0"
+name = "prettydiff"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd04b170004fa2daccf418a7f8253aaf033c27760b5f225889024cf66d7ac2e"
+checksum = "abec3fb083c10660b3854367697da94c674e9e82aa7511014dc958beeb7215e9"
 dependencies = [
- "atty",
- "csv",
- "encode_unicode 0.3.6",
- "lazy_static",
- "term 0.5.2",
- "unicode-width",
+ "owo-colors 3.5.0",
+ "pad",
+ "prettytable-rs",
 ]
 
 [[package]]
@@ -5110,7 +5915,7 @@ dependencies = [
  "encode_unicode 1.0.0",
  "is-terminal",
  "lazy_static",
- "term 0.7.0",
+ "term",
  "unicode-width",
 ]
 
@@ -5148,11 +5953,11 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.1.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
+checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b"
 dependencies = [
- "toml_edit 0.21.1",
+ "toml_edit",
 ]
 
 [[package]]
@@ -5179,30 +5984,24 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "proc-macro-hack"
-version = "0.5.20+deprecated"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
-
 [[package]]
 name = "proc-macro2"
-version = "1.0.83"
+version = "1.0.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b33eb56c327dec362a9e55b3ad14f9d2f0904fb5a5b03b513ab5465399e9f43"
+checksum = "7c3a7fc5db1e57d5a779a352c8cdb57b29aa4c40cc69c3a68a7fedc815fbf2f9"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "prometheus-client"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1ca959da22a332509f2a73ae9e5f23f9dcfc31fd3a54d71f159495bd5909baa"
+checksum = "504ee9ff529add891127c4827eb481bd69dc0ebc72e9a682e187db4caa60c3ca"
 dependencies = [
  "dtoa",
  "itoa",
- "parking_lot 0.12.2",
+ "parking_lot 0.12.3",
  "prometheus-client-derive-encode",
 ]
 
@@ -5214,7 +6013,27 @@ checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "proptest"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d"
+dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags 2.6.0",
+ "lazy_static",
+ "num-traits",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "regex-syntax 0.8.5",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
 ]
 
 [[package]]
@@ -5223,6 +6042,26 @@ version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac"
 
+[[package]]
+name = "ptr_meta"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+dependencies = [
+ "ptr_meta_derive",
+]
+
+[[package]]
+name = "ptr_meta_derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "ptyprocess"
 version = "0.4.1"
@@ -5248,7 +6087,7 @@ version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76979bea66e7875e7509c4ec5300112b316af87fa7a252ca91c448b32dfe3993"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "memchr",
  "pulldown-cmark-escape",
  "unicase",
@@ -5260,6 +6099,12 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd348ff538bc9caeda7ee8cad2d1d48236a1f443c1fa3913c6a02fe0043b1dd3"
 
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
 [[package]]
 name = "quick-protobuf"
 version = "0.8.1"
@@ -5271,18 +6116,18 @@ dependencies = [
 
 [[package]]
 name = "quick-xml"
-version = "0.31.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
+checksum = "1d3a6e5838b60e0e8fa7a43f22ade549a37d61f8bdbe636d0d7816191de969c2"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
@@ -5330,7 +6175,16 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
 ]
 
 [[package]]
@@ -5373,12 +6227,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "redox_syscall"
-version = "0.1.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
-
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
@@ -5399,11 +6247,11 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.1"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -5414,36 +6262,25 @@ checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
 
 [[package]]
 name = "redox_users"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"
-dependencies = [
- "getrandom 0.1.16",
- "redox_syscall 0.1.57",
- "rust-argon2",
-]
-
-[[package]]
-name = "redox_users"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom",
  "libredox 0.1.3",
  "thiserror",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.4"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.6",
- "regex-syntax 0.8.3",
+ "regex-automata 0.4.8",
+ "regex-syntax 0.8.5",
 ]
 
 [[package]]
@@ -5457,15 +6294,21 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.6"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.3",
+ "regex-syntax 0.8.5",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
+
 [[package]]
 name = "regex-syntax"
 version = "0.6.29"
@@ -5474,9 +6317,18 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.3"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rend"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
+checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
+dependencies = [
+ "bytecheck",
+]
 
 [[package]]
 name = "reqwest"
@@ -5491,29 +6343,26 @@ dependencies = [
  "encoding_rs",
  "futures-core",
  "futures-util",
- "h2",
- "http",
- "http-body",
- "hyper",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "hyper 0.14.31",
  "hyper-rustls 0.24.2",
- "hyper-tls",
  "ipnet",
  "js-sys",
  "log",
  "mime",
- "native-tls",
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
  "rustls 0.21.12",
- "rustls-pemfile",
+ "rustls-pemfile 1.0.4",
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sync_wrapper",
- "system-configuration",
+ "sync_wrapper 0.1.2",
+ "system-configuration 0.5.1",
  "tokio",
- "tokio-native-tls",
  "tokio-rustls 0.24.1",
  "tower-service",
  "url",
@@ -5524,41 +6373,113 @@ dependencies = [
  "winreg",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.12.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f713147fbe92361e52392c73b8c9e48c04c6625bce969ef54dc901e58e042a7b"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2 0.4.6",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.5.0",
+ "hyper-rustls 0.27.3",
+ "hyper-tls",
+ "hyper-util",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pemfile 2.2.0",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper 1.0.1",
+ "system-configuration 0.6.1",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-registry",
+]
+
 [[package]]
 name = "revm"
-version = "2.3.1"
+version = "14.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73d84c8f9836efb0f5f5f8de4700a953c4e1f3119e5cfcb0aad8e5be73daf991"
+checksum = "641702b12847f9ed418d552f4fcabe536d867a2c980e96b6e7e25d7b992f929f"
 dependencies = [
- "arrayref",
  "auto_impl",
- "bytes",
- "hashbrown 0.13.2",
- "num_enum 0.5.11",
- "primitive-types",
- "revm_precompiles",
- "rlp",
- "sha3",
+ "cfg-if 1.0.0",
+ "dyn-clone",
+ "revm-interpreter",
+ "revm-precompile",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "revm_precompiles"
-version = "1.1.2"
+name = "revm-interpreter"
+version = "10.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0353d456ef3e989dc9190f42c6020f09bc2025930c37895826029304413204b5"
+checksum = "2e5e14002afae20b5bf1566f22316122f42f57517000e559c55b25bf7a49cba2"
 dependencies = [
- "bytes",
- "hashbrown 0.13.2",
- "num",
+ "revm-primitives",
+ "serde",
+]
+
+[[package]]
+name = "revm-precompile"
+version = "11.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3198c06247e8d4ad0d1312591edf049b0de4ddffa9fecb625c318fd67db8639b"
+dependencies = [
+ "aurora-engine-modexp",
+ "blst",
+ "c-kzg",
+ "cfg-if 1.0.0",
+ "k256",
  "once_cell",
- "primitive-types",
+ "revm-primitives",
  "ripemd",
- "secp256k1 0.24.3",
+ "secp256k1",
  "sha2 0.10.8",
- "sha3",
  "substrate-bn",
 ]
 
+[[package]]
+name = "revm-primitives"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f1525851a03aff9a9d6a1d018b414d76252d6802ab54695b27093ecd7e7a101"
+dependencies = [
+ "alloy-eip2930",
+ "alloy-eip7702",
+ "alloy-primitives",
+ "auto_impl",
+ "bitflags 2.6.0",
+ "bitvec",
+ "c-kzg",
+ "cfg-if 1.0.0",
+ "dyn-clone",
+ "enumn",
+ "hex",
+ "serde",
+]
+
 [[package]]
 name = "rexpect"
 version = "0.4.0"
@@ -5572,28 +6493,26 @@ dependencies = [
 ]
 
 [[package]]
-name = "rfc6979"
-version = "0.4.0"
+name = "rexpect"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+checksum = "01ff60778f96fb5a48adbe421d21bf6578ed58c0872d712e7e08593c195adff8"
 dependencies = [
- "hmac 0.12.1",
- "subtle",
+ "comma",
+ "nix 0.25.1",
+ "regex",
+ "tempfile",
+ "thiserror",
 ]
 
 [[package]]
-name = "ring"
-version = "0.16.20"
+name = "rfc6979"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
 dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin 0.5.2",
- "untrusted 0.7.1",
- "web-sys",
- "winapi",
+ "hmac 0.12.1",
+ "subtle",
 ]
 
 [[package]]
@@ -5604,10 +6523,10 @@ checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
 dependencies = [
  "cc",
  "cfg-if 1.0.0",
- "getrandom 0.2.15",
+ "getrandom",
  "libc",
- "spin 0.9.8",
- "untrusted 0.9.0",
+ "spin",
+ "untrusted",
  "windows-sys 0.52.0",
 ]
 
@@ -5620,6 +6539,35 @@ dependencies = [
  "digest 0.10.7",
 ]
 
+[[package]]
+name = "rkyv"
+version = "0.7.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9008cd6385b9e161d8229e1f6549dd23c3d022f132a2ea37ac3a10ac4935779b"
+dependencies = [
+ "bitvec",
+ "bytecheck",
+ "bytes",
+ "hashbrown 0.12.3",
+ "ptr_meta",
+ "rend",
+ "rkyv_derive",
+ "seahash",
+ "tinyvec",
+ "uuid 1.11.0",
+]
+
+[[package]]
+name = "rkyv_derive"
+version = "0.7.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "503d1d27590a2b0a3a4ca4c94755aa2875657196ecbf401a42eff41d7de532c0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "rlp"
 version = "0.5.2"
@@ -5653,14 +6601,13 @@ dependencies = [
 
 [[package]]
 name = "rowan"
-version = "0.14.1"
+version = "0.15.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f77412a3d1f26af0c0783c23b3555a301b1a49805cba7bf9a7827a9e9e285f0"
+checksum = "0a542b0253fa46e632d27a1dc5cf7b930de4df8659dc6e720b647fc72147ae3d"
 dependencies = [
  "countme",
- "hashbrown 0.11.2",
- "memoffset 0.6.5",
- "rustc-hash",
+ "hashbrown 0.14.5",
+ "rustc-hash 1.1.0",
  "text-size",
 ]
 
@@ -5686,15 +6633,49 @@ dependencies = [
 ]
 
 [[package]]
-name = "rust-argon2"
-version = "0.8.3"
+name = "ruint"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c3cc4c2511671f327125da14133d0c5c5d137f006a1017a16f557bc85b16286"
+dependencies = [
+ "alloy-rlp",
+ "ark-ff 0.3.0",
+ "ark-ff 0.4.2",
+ "bytes",
+ "fastrlp",
+ "num-bigint",
+ "num-traits",
+ "parity-scale-codec",
+ "primitive-types",
+ "proptest",
+ "rand",
+ "rlp",
+ "ruint-macro",
+ "serde",
+ "valuable",
+ "zeroize",
+]
+
+[[package]]
+name = "ruint-macro"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
+
+[[package]]
+name = "rust_decimal"
+version = "1.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b18820d944b33caa75a71378964ac46f58517c92b6ae5f762636247c09e78fb"
+checksum = "b082d80e3e3cc52b2ed634388d436fe1f4de6af5786cc2de9ba9737527bdf555"
 dependencies = [
- "base64 0.13.1",
- "blake2b_simd 0.5.11",
- "constant_time_eq 0.1.5",
- "crossbeam-utils",
+ "arrayvec",
+ "borsh",
+ "bytes",
+ "num-traits",
+ "rand",
+ "rkyv",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
@@ -5709,6 +6690,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
+
 [[package]]
 name = "rustc-hex"
 version = "2.1.0"
@@ -5717,37 +6704,33 @@ checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
 dependencies = [
- "semver",
+ "semver 0.11.0",
 ]
 
 [[package]]
-name = "rustix"
-version = "0.38.34"
+name = "rustc_version"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
- "bitflags 2.5.0",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys 0.52.0",
+ "semver 1.0.23",
 ]
 
 [[package]]
-name = "rustls"
-version = "0.19.1"
+name = "rustix"
+version = "0.38.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35edb675feee39aec9c99fa5ff985081995a06d594114ae14cbe797ad7b7a6d7"
+checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
 dependencies = [
- "base64 0.13.1",
- "log",
- "ring 0.16.20",
- "sct 0.6.1",
- "webpki",
+ "bitflags 2.6.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -5757,21 +6740,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring 0.17.8",
- "rustls-webpki",
- "sct 0.7.1",
+ "ring",
+ "rustls-webpki 0.101.7",
+ "sct",
 ]
 
 [[package]]
-name = "rustls-native-certs"
-version = "0.5.0"
+name = "rustls"
+version = "0.23.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a07b7c1885bd8ed3831c289b7870b13ef46fe0e856d288c30d9cc17d75a2092"
+checksum = "5fbb44d7acc4e873d613422379f69f237a1b141928c02f6bc6ccfddddc2d7993"
 dependencies = [
- "openssl-probe",
- "rustls 0.19.1",
- "schannel",
- "security-framework",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
@@ -5781,7 +6765,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
 dependencies = [
  "openssl-probe",
- "rustls-pemfile",
+ "rustls-pemfile 1.0.4",
  "schannel",
  "security-framework",
 ]
@@ -5795,40 +6779,76 @@ dependencies = [
  "base64 0.21.7",
 ]
 
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16f1201b3c9a7ee8039bcadc17b7e605e2945b27eee7631788c1bd2b0643674b"
+
 [[package]]
 name = "rustls-webpki"
 version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"
+
+[[package]]
+name = "rusty-fork"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
 
 [[package]]
 name = "rustyline"
-version = "8.2.0"
+version = "13.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbd4eaf7a7738f76c98e4f0395253ae853be3eb018f7b0bb57fe1b6c17e31874"
+checksum = "02a2d683a4ac90aeef5b1013933f6d977bd37d51ff3f4dad829d4931a7e6be86"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "cfg-if 1.0.0",
  "clipboard-win",
- "dirs-next",
- "fd-lock 2.0.0",
+ "fd-lock",
+ "home",
  "libc",
  "log",
  "memchr",
- "nix 0.20.0",
+ "nix 0.27.1",
  "radix_trie",
- "scopeguard",
- "smallvec",
  "unicode-segmentation",
  "unicode-width",
  "utf8parse",
@@ -5837,12 +6857,10 @@ dependencies = [
 
 [[package]]
 name = "ruzstd"
-version = "0.5.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
+checksum = "99c3938e133aac070997ddc684d4b393777d293ba170f2988c8fd5ea2ad4ce21"
 dependencies = [
- "byteorder",
- "derive_more",
  "twox-hash",
 ]
 
@@ -5872,20 +6890,20 @@ dependencies = [
 
 [[package]]
 name = "scc"
-version = "2.1.1"
+version = "2.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76ad2bbb0ae5100a07b7a6f2ed7ab5fd0045551a4c507989b7a620046ea3efdc"
+checksum = "f2c1f7fc6deb21665a9060dfc7d271be784669295a31babdcd4dd2c79ae8cbfb"
 dependencies = [
  "sdd",
 ]
 
 [[package]]
 name = "schannel"
-version = "0.1.23"
+version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+checksum = "01227be5826fa0690321a2ba6c5cd57a19cf3f6a09e76973b58e61de6ab9d1c1"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5932,31 +6950,27 @@ dependencies = [
  "sha2 0.10.8",
 ]
 
-[[package]]
-name = "sct"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce"
-dependencies = [
- "ring 0.16.20",
- "untrusted 0.7.1",
-]
-
 [[package]]
 name = "sct"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
 ]
 
 [[package]]
 name = "sdd"
-version = "0.2.0"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49c1eeaf4b6a87c7479688c6d52b9f1153cedd3c489300564f932b065c6eab95"
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b84345e4c9bd703274a082fb80caaa99b7612be48dfaa1dd9266577ec412309d"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
 [[package]]
 name = "sec1"
@@ -5974,37 +6988,19 @@ dependencies = [
 
 [[package]]
 name = "secp256k1"
-version = "0.24.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b1629c9c557ef9b293568b338dddfc8208c98a18c59d722a9d53f859d9c9b62"
-dependencies = [
- "secp256k1-sys 0.6.1",
-]
-
-[[package]]
-name = "secp256k1"
-version = "0.26.0"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4124a35fe33ae14259c490fd70fa199a32b9ce9502f2ee6bc4f81ec06fa65894"
+checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
 dependencies = [
  "rand",
- "secp256k1-sys 0.8.1",
+ "secp256k1-sys",
 ]
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83080e2c2fc1006e625be82e5d1eb6a43b7fd9578b617fcc55814daf286bba4b"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "secp256k1-sys"
-version = "0.8.1"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70a129b9e9efbfb223753b9163c4ab3b13cff7fd9c7f010fbac25ab4099fa07e"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
 dependencies = [
  "cc",
 ]
@@ -6020,11 +7016,11 @@ dependencies = [
 
 [[package]]
 name = "security-framework"
-version = "2.11.0"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "core-foundation",
  "core-foundation-sys",
  "libc",
@@ -6033,14 +7029,23 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.11.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7"
+checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6"
 dependencies = [
  "core-foundation-sys",
  "libc",
 ]
 
+[[package]]
+name = "semver"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+dependencies = [
+ "semver-parser",
+]
+
 [[package]]
 name = "semver"
 version = "1.0.23"
@@ -6050,24 +7055,33 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "semver-parser"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
+dependencies = [
+ "pest",
+]
+
 [[package]]
 name = "serde"
-version = "1.0.202"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.202"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -6081,11 +7095,13 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "6dbcf9b78a125ee667ae19388837dd12294b858d101fdd393cb9d5501ef09eb2"
 dependencies = [
+ "indexmap 2.6.0",
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
@@ -6098,14 +7114,14 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
 dependencies = [
  "serde",
 ]
@@ -6124,15 +7140,15 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.8.1"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ad483d2ab0149d5a5ebcd9972a3852711e0153d863bf5a5d0391d28883c4a20"
+checksum = "8e28bdad6db2b8340e449f7108f020b3b092e8583a9e3fb82713e1d4e71fe817"
 dependencies = [
  "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "serde",
  "serde_derive",
  "serde_json",
@@ -6142,14 +7158,14 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.8.1"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2"
+checksum = "9d846214a9854ef724f3da161b426242d8de7c1fc7de2f89bb1efcb154dca79d"
 dependencies = [
- "darling 0.20.9",
+ "darling 0.20.10",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -6158,7 +7174,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "itoa",
  "ryu",
  "serde",
@@ -6174,7 +7190,7 @@ dependencies = [
  "futures",
  "log",
  "once_cell",
- "parking_lot 0.12.2",
+ "parking_lot 0.12.3",
  "scc",
  "serial_test_derive",
 ]
@@ -6187,7 +7203,7 @@ checksum = "82fe9db325bcef1fbcde82e078a5cc4efdf787e96b3b9cf45b50b529f2083d67"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -6224,6 +7240,16 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "sha3-asm"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46"
+dependencies = [
+ "cc",
+ "cfg-if 1.0.0",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -6233,6 +7259,16 @@ dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "shared_child"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09fa9338aed9a1df411814a5b2252f7cd206c55ae9bf2fa763f8de84603aa60c"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "shell-words"
 version = "1.1.0"
@@ -6241,15 +7277,17 @@ checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
 [[package]]
 name = "shellfish"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c66e6fc7a668d89939ee241fb342f401f8c11a80da8fb72fd14681f8d47440b"
+checksum = "fef42fa3356b28a29aee098d1656681670da7eb15be0e89bba6f05aea540df3d"
 dependencies = [
  "async-trait",
  "cfg-if 1.0.0",
  "rustyline",
+ "thiserror",
  "tokio",
- "yansi",
+ "version_check",
+ "yansi 0.5.1",
 ]
 
 [[package]]
@@ -6277,11 +7315,17 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
 [[package]]
 name = "similar"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"
 
 [[package]]
 name = "siphasher"
@@ -6319,9 +7363,9 @@ dependencies = [
 
 [[package]]
 name = "slug"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bd94acec9c8da640005f8e135a39fc0372e74535e6b368b7a04b875f784c8c4"
+checksum = "882a80f72ee45de3cc9a5afeb2da0331d58df69e4e7d8eeb5d3c7784ae67e724"
 dependencies = [
  "deunicode",
  "wasm-bindgen",
@@ -6372,12 +7416,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -6409,12 +7447,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
-[[package]]
-name = "str-buf"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0"
-
 [[package]]
 name = "str_indices"
 version = "0.4.3"
@@ -6478,6 +7510,15 @@ version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
 
+[[package]]
+name = "strum"
+version = "0.26.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
+dependencies = [
+ "strum_macros 0.26.4",
+]
+
 [[package]]
 name = "strum_macros"
 version = "0.24.3"
@@ -6501,7 +7542,20 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.65",
+ "syn 2.0.79",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -6519,13 +7573,13 @@ dependencies = [
 
 [[package]]
 name = "subtle"
-version = "2.5.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "sway-ast"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "extension-trait",
  "num-bigint",
@@ -6537,11 +7591,11 @@ dependencies = [
 
 [[package]]
 name = "sway-core"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
- "clap 4.5.4",
+ "clap 4.5.20",
  "derivative",
- "dirs 3.0.2",
+ "dirs 5.0.1",
  "either",
  "fuel-abi-types",
  "fuel-ethabi",
@@ -6550,23 +7604,22 @@ dependencies = [
  "fuel-vm",
  "gimli",
  "graph-cycles",
- "hashbrown 0.13.2",
+ "hashbrown 0.14.5",
  "hex",
  "im",
- "indexmap 2.2.6",
- "itertools 0.10.5",
+ "indexmap 2.6.0",
+ "itertools 0.13.0",
  "lazy_static",
- "miden-core",
  "object",
- "parking_lot 0.12.2",
+ "parking_lot 0.12.3",
  "pest",
  "pest_derive",
  "petgraph",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "serde",
  "serde_json",
- "sha2 0.9.9",
- "strum 0.24.1",
+ "sha2 0.10.8",
+ "strum 0.26.3",
  "sway-ast",
  "sway-error",
  "sway-ir",
@@ -6582,12 +7635,13 @@ dependencies = [
 
 [[package]]
 name = "sway-error"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "either",
  "in_definite",
  "num-traits",
  "smallvec",
+ "strsim 0.11.1",
  "sway-types",
  "thiserror",
  "uwuify",
@@ -6595,17 +7649,17 @@ dependencies = [
 
 [[package]]
 name = "sway-ir"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
  "downcast-rs",
  "filecheck",
- "indexmap 2.2.6",
- "itertools 0.10.5",
+ "indexmap 2.6.0",
+ "itertools 0.13.0",
  "once_cell",
  "peg",
- "prettydiff 0.6.4",
- "rustc-hash",
+ "prettydiff 0.7.0",
+ "rustc-hash 1.1.0",
  "slotmap",
  "sway-ir-macros",
  "sway-types",
@@ -6614,34 +7668,35 @@ dependencies = [
 
 [[package]]
 name = "sway-ir-macros"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
- "itertools 0.10.5",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "sway-lsp"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
  "assert-json-diff",
+ "codspeed-criterion-compat",
  "criterion",
  "crossbeam-channel",
- "dashmap",
+ "dashmap 6.1.0",
  "dirs 4.0.0",
- "fd-lock 4.0.2",
+ "fd-lock",
  "forc-pkg",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
  "forc-util",
  "futures",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "lsp-types",
  "notify",
  "notify-debouncer-mini",
- "parking_lot 0.12.2",
+ "parking_lot 0.12.3",
  "pretty_assertions",
  "proc-macro2",
  "quote",
@@ -6649,7 +7704,6 @@ dependencies = [
  "rayon",
  "rayon-cond",
  "regex",
- "ropey",
  "serde",
  "serde_json",
  "sway-ast",
@@ -6660,13 +7714,13 @@ dependencies = [
  "sway-types",
  "sway-utils",
  "swayfmt",
- "syn 1.0.109",
+ "syn 2.0.79",
  "tempfile",
  "thiserror",
  "tikv-jemallocator",
  "tokio",
- "toml_edit 0.19.15",
- "tower",
+ "toml_edit",
+ "tower 0.4.13",
  "tower-lsp",
  "tracing",
  "urlencoding",
@@ -6674,7 +7728,7 @@ dependencies = [
 
 [[package]]
 name = "sway-lsp-test-utils"
-version = "0.1.0"
+version = "0.66.2"
 dependencies = [
  "assert-json-diff",
  "futures",
@@ -6683,13 +7737,13 @@ dependencies = [
  "serde",
  "serde_json",
  "tokio",
- "tower",
+ "tower 0.5.1",
  "tower-lsp",
 ]
 
 [[package]]
 name = "sway-parse"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "assert_matches",
  "extension-trait",
@@ -6707,18 +7761,18 @@ dependencies = [
 
 [[package]]
 name = "sway-types"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "bytecount",
  "fuel-asm",
  "fuel-crypto",
  "fuel-tx",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "lazy_static",
  "num-bigint",
  "num-traits",
- "parking_lot 0.12.2",
- "rustc-hash",
+ "parking_lot 0.12.3",
+ "rustc-hash 1.1.0",
  "serde",
  "sway-utils",
  "thiserror",
@@ -6726,7 +7780,7 @@ dependencies = [
 
 [[package]]
 name = "sway-utils"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "serde",
  "walkdir",
@@ -6734,11 +7788,12 @@ dependencies = [
 
 [[package]]
 name = "swayfmt"
-version = "0.60.0"
+version = "0.66.2"
 dependencies = [
  "anyhow",
  "difference",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
+ "indoc",
  "paste",
  "prettydiff 0.6.4",
  "ropey",
@@ -6752,7 +7807,7 @@ dependencies = [
  "sway-utils",
  "test-macros",
  "thiserror",
- "toml 0.7.8",
+ "toml 0.8.19",
 ]
 
 [[package]]
@@ -6768,21 +7823,42 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.65"
+version = "2.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2863d96a84c6439701d7a38f9de935ec562c8832cc55d1dde0f513b52fad106"
+checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "syn_derive"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1329189c02ff984e9736652b1631330da25eaa6bc639089ed4915d25446cbe7b"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.79",
+]
+
 [[package]]
 name = "sync_wrapper"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
+[[package]]
+name = "sync_wrapper"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+dependencies = [
+ "futures-core",
+]
+
 [[package]]
 name = "synstructure"
 version = "0.12.6"
@@ -6803,7 +7879,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -6820,7 +7896,7 @@ dependencies = [
  "once_cell",
  "onig",
  "plist",
- "regex-syntax 0.8.3",
+ "regex-syntax 0.8.5",
  "serde",
  "serde_derive",
  "serde_json",
@@ -6852,7 +7928,18 @@ checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation",
- "system-configuration-sys",
+ "system-configuration-sys 0.5.0",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+dependencies = [
+ "bitflags 2.6.0",
+ "core-foundation",
+ "system-configuration-sys 0.6.0",
 ]
 
 [[package]]
@@ -6865,6 +7952,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "tai64"
 version = "4.0.0"
@@ -6882,53 +7979,47 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "taplo"
-version = "0.7.0"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5d17cb5ff4095af064048f25a0a8df815384f63ce21c7410e96b93016757259"
+checksum = "010941ac4171eaf12f1e26dfc11dadaf78619ea2330940fef01fe6bb0442d14d"
 dependencies = [
- "glob",
- "indexmap 1.9.3",
+ "ahash 0.8.11",
+ "arc-swap",
+ "either",
+ "globset",
+ "itertools 0.10.5",
  "logos",
- "regex",
+ "once_cell",
  "rowan",
- "semver",
- "smallvec",
- "toml 0.5.11",
- "wasm-bindgen",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "time",
+ "tracing",
 ]
 
 [[package]]
 name = "tar"
-version = "0.4.40"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+checksum = "4ff6c40d3aedb5e06b57c6f669ad17ab063dd1e63d977c6a88e7f4dfa4f04020"
 dependencies = [
  "filetime",
  "libc",
  "xattr",
 ]
 
-[[package]]
-name = "tempfile"
-version = "3.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
-dependencies = [
- "cfg-if 1.0.0",
- "fastrand",
- "rustix",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "term"
-version = "0.5.2"
+[[package]]
+name = "tempfile"
+version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd106a334b7657c10b7c540a0106114feadeb4dc314513e97df481d5d966f42"
+checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
 dependencies = [
- "byteorder",
- "dirs 1.0.5",
- "winapi",
+ "cfg-if 1.0.0",
+ "fastrand",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6944,23 +8035,32 @@ dependencies = [
 
 [[package]]
 name = "term-table"
-version = "1.3.2"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5e59d7fb313157de2a568be8d81e4d7f9af6e50e697702e8e00190a6566d3b8"
+checksum = "210f90191b719267bc8b6307659faf54a77400d06b8033ece26692696fc002be"
 dependencies = [
  "lazy_static",
  "regex",
  "unicode-width",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "terminal_size"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
+checksum = "4f599bd7ca042cfdf8f4512b277c02ba102247820f9d9d4a9f521f496751a6ef"
 dependencies = [
  "rustix",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6971,7 +8071,19 @@ checksum = "c4648c7def6f2043b2568617b9f9b75eae88ca185dbc1f1fda30e95a85d49d7d"
 dependencies = [
  "libc",
  "libredox 0.0.2",
- "numtoa",
+ "numtoa 0.1.0",
+ "redox_termios",
+]
+
+[[package]]
+name = "termion"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eaa98560e51a2cf4f0bb884d8b2098a9ea11ecf3b7078e9c68242c74cc923a7"
+dependencies = [
+ "libc",
+ "libredox 0.1.3",
+ "numtoa 0.2.4",
  "redox_termios",
 ]
 
@@ -6981,20 +8093,24 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "bytes",
- "clap 4.5.4",
+ "clap 4.5.20",
  "colored",
+ "duct",
  "filecheck",
  "forc",
  "forc-client",
  "forc-pkg",
  "forc-test",
- "forc-tracing 0.60.0",
+ "forc-tracing 0.66.2",
  "fuel-vm",
  "futures",
  "gag",
+ "glob",
  "hex",
- "miden",
- "prettydiff 0.6.4",
+ "insta",
+ "libtest-mimic",
+ "normalize-path",
+ "prettydiff 0.7.0",
  "rand",
  "regex",
  "revm",
@@ -7006,8 +8122,9 @@ dependencies = [
  "sway-utils",
  "textwrap 0.16.1",
  "tokio",
- "toml 0.7.8",
+ "toml 0.8.19",
  "tracing",
+ "vte 0.13.0",
 ]
 
 [[package]]
@@ -7046,22 +8163,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -7074,11 +8191,20 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
 [[package]]
 name = "tikv-jemalloc-sys"
-version = "0.5.4+5.3.0-patched"
+version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9402443cb8fd499b6f327e40565234ff34dbda27460c5b47db0db77443dd85d1"
+checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
 dependencies = [
  "cc",
  "libc",
@@ -7086,9 +8212,9 @@ dependencies = [
 
 [[package]]
 name = "tikv-jemallocator"
-version = "0.5.4"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "965fe0c26be5c56c94e38ba547249074803efd52adfb66de62107d95aab3eaca"
+checksum = "4cec5ff18518d81584f477e9bfdf957f5bb0979b0bac3af4ca30b5b3ae2d2865"
 dependencies = [
  "libc",
  "tikv-jemalloc-sys",
@@ -7136,7 +8262,7 @@ dependencies = [
  "once_cell",
  "pbkdf2 0.11.0",
  "rand",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "sha2 0.10.8",
  "thiserror",
  "unicode-normalization",
@@ -7165,9 +8291,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -7180,21 +8306,20 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.37.0"
+version = "1.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
+checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998"
 dependencies = [
  "backtrace",
  "bytes",
  "libc",
- "mio",
- "num_cpus",
- "parking_lot 0.12.2",
+ "mio 1.0.2",
+ "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -7209,13 +8334,13 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "2.2.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -7230,30 +8355,30 @@ dependencies = [
 
 [[package]]
 name = "tokio-rustls"
-version = "0.22.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc6844de72e57df1980054b38be3a9f4702aba4858be64dd700181a8a6d0e1b6"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
- "rustls 0.19.1",
+ "rustls 0.21.12",
  "tokio",
- "webpki",
 ]
 
 [[package]]
 name = "tokio-rustls"
-version = "0.24.1"
+version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
 dependencies = [
- "rustls 0.21.12",
+ "rustls 0.23.15",
+ "rustls-pki-types",
  "tokio",
 ]
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
+checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -7262,9 +8387,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
  "bytes",
  "futures-core",
@@ -7284,49 +8409,38 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.7.8"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
+checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit 0.19.15",
+ "toml_edit",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.19.15"
+version = "0.22.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
  "winnow",
 ]
 
-[[package]]
-name = "toml_edit"
-version = "0.21.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
-dependencies = [
- "indexmap 2.2.6",
- "toml_datetime",
- "winnow",
-]
-
 [[package]]
 name = "topological-sort"
 version = "0.2.2"
@@ -7343,36 +8457,29 @@ dependencies = [
  "futures-util",
  "pin-project",
  "pin-project-lite",
- "tokio",
  "tower-layer",
  "tower-service",
- "tracing",
 ]
 
 [[package]]
-name = "tower-http"
-version = "0.3.5"
+name = "tower"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f873044bf02dd1e8239e9c1293ea39dad76dc594ec16185d0a1bf31d8dc8d858"
+checksum = "2873938d487c3cfb9aed7546dc9f2711d867c9f90c46b889989a2cb84eba6b4f"
 dependencies = [
- "bitflags 1.3.2",
- "bytes",
  "futures-core",
  "futures-util",
- "http",
- "http-body",
- "http-range-header",
  "pin-project-lite",
- "tower",
+ "sync_wrapper 0.1.2",
  "tower-layer",
  "tower-service",
 ]
 
 [[package]]
 name = "tower-layer"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
 
 [[package]]
 name = "tower-lsp"
@@ -7383,7 +8490,7 @@ dependencies = [
  "async-trait",
  "auto_impl",
  "bytes",
- "dashmap",
+ "dashmap 5.5.3",
  "futures",
  "httparse",
  "lsp-types",
@@ -7392,7 +8499,7 @@ dependencies = [
  "serde_json",
  "tokio",
  "tokio-util",
- "tower",
+ "tower 0.4.13",
  "tower-lsp-macros",
  "tracing",
 ]
@@ -7405,14 +8512,14 @@ checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "tower-service"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
@@ -7420,7 +8527,6 @@ version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
- "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
@@ -7434,7 +8540,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
@@ -7489,6 +8595,27 @@ dependencies = [
  "tracing-serde",
 ]
 
+[[package]]
+name = "tracing-test"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "557b891436fe0d5e0e363427fc7f217abf9ccd510d5136549847bdcbcd011d68"
+dependencies = [
+ "tracing-core",
+ "tracing-subscriber",
+ "tracing-test-macro",
+]
+
+[[package]]
+name = "tracing-test-macro"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
+dependencies = [
+ "quote",
+ "syn 2.0.79",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -7530,9 +8657,9 @@ checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
 [[package]]
 name = "uint"
@@ -7546,6 +8673,12 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
 [[package]]
 name = "unicase"
 version = "2.7.0"
@@ -7557,15 +8690,15 @@ dependencies = [
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.15"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
 name = "unicode-linebreak"
@@ -7575,30 +8708,30 @@ checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
 dependencies = [
  "tinyvec",
 ]
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "unicode_categories"
@@ -7628,10 +8761,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6889a77d49f1f013504cec6bf97a2c730394adedaeb1deb5ea08949a50541105"
 
 [[package]]
-name = "untrusted"
-version = "0.7.1"
+name = "unsigned-varint"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
 
 [[package]]
 name = "untrusted"
@@ -7641,9 +8774,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.5.0"
+version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
 dependencies = [
  "form_urlencoded",
  "idna 0.5.0",
@@ -7657,11 +8790,17 @@ version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
 
+[[package]]
+name = "utf8-width"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86bd8d4e895da8537e5315b8254664e6b769c4ff3db18321b297a1e7004392e3"
+
 [[package]]
 name = "utf8parse"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
@@ -7669,10 +8808,16 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom",
  "serde",
 ]
 
+[[package]]
+name = "uuid"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a"
+
 [[package]]
 name = "uwuify"
 version = "0.2.2"
@@ -7680,7 +8825,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3db6840b7adcfd2e866c79157cc890ecdbbc1f739607134039ae64eaa6c07e24"
 dependencies = [
  "clap 2.34.0",
- "owo-colors",
+ "owo-colors 1.3.0",
  "parking_lot 0.11.2",
  "thiserror",
 ]
@@ -7699,9 +8844,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "vec1"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb60dcfffc189bfd4e2a81333c268619fee9db53da71bce2bcbd8e129c56936"
+checksum = "eab68b56840f69efb0fefbe3ab6661499217ffdc58e2eef7c3f6f69835386322"
 
 [[package]]
 name = "vec_map"
@@ -7711,9 +8856,9 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "void"
@@ -7721,6 +8866,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
 
+[[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
 [[package]]
 name = "vt100"
 version = "0.15.2"
@@ -7730,7 +8881,7 @@ dependencies = [
  "itoa",
  "log",
  "unicode-width",
- "vte",
+ "vte 0.11.1",
 ]
 
 [[package]]
@@ -7739,21 +8890,41 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f5022b5fbf9407086c180e9557be968742d839e68346af7792b8592489732197"
 dependencies = [
- "arrayvec 0.7.4",
+ "arrayvec",
+ "utf8parse",
+ "vte_generate_state_changes",
+]
+
+[[package]]
+name = "vte"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40eb22ae96f050e0c0d6f7ce43feeae26c348fc4dea56928ca81537cfaa6188b"
+dependencies = [
+ "arrayvec",
  "utf8parse",
  "vte_generate_state_changes",
 ]
 
 [[package]]
 name = "vte_generate_state_changes"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
+checksum = "2e369bee1b05d510a7b4ed645f5faa90619e05437111783ea5848f28d97d3c2e"
 dependencies = [
  "proc-macro2",
  "quote",
 ]
 
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -7773,12 +8944,6 @@ dependencies = [
  "try-lock",
 ]
 
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
@@ -7793,36 +8958,35 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "128d1e363af62632b8eb57219c8fd7877144af57558fb2ef0368d0087bddeb2e"
 dependencies = [
  "cfg-if 1.0.0",
- "serde",
- "serde_json",
+ "once_cell",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "cb6dd4d3ca0ddffd1dd1c9c04f94b868c37ff5fac97c30b97cff2d74fce3a358"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.42"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+checksum = "cc7ec4f8827a71586374db3e87abdb5a2bb3a15afed140221307c3ec06b1f63b"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -7832,9 +8996,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "e79384be7f8f5a9dd5d7167216f022090cf1f9ec128e6e6a482a2cb5c5422c56"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -7842,43 +9006,33 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d"
 
 [[package]]
 name = "web-sys"
-version = "0.3.69"
+version = "0.3.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+checksum = "f6488b90108c040df0fe62fa815cbdee25124641df01814dd7282749234c6112"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "webpki"
-version = "0.21.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea"
-dependencies = [
- "ring 0.16.20",
- "untrusted 0.7.1",
-]
-
 [[package]]
 name = "webpki-roots"
 version = "0.25.4"
@@ -7887,9 +9041,9 @@ checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
 name = "which"
-version = "6.0.1"
+version = "6.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8211e4f58a2b2805adfbefbc07bab82958fc91e3836339b1ab7ae32465dce0d7"
+checksum = "b4ee928febd44d98f2f459a4a79bd4d928591333a494a10a868418ac1b39cf1f"
 dependencies = [
  "either",
  "home",
@@ -7899,11 +9053,11 @@ dependencies = [
 
 [[package]]
 name = "whoami"
-version = "1.5.1"
+version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
+checksum = "372d5b87f58ec45c384ba03563b03544dc5fadc3983e434b286913f5b4a9bb6d"
 dependencies = [
- "redox_syscall 0.4.1",
+ "redox_syscall 0.5.7",
  "wasite",
  "web-sys",
 ]
@@ -7926,11 +9080,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -7945,16 +9099,37 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.45.0"
+name = "windows-registry"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
+dependencies = [
+ "windows-result",
+ "windows-strings",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
 dependencies = [
- "windows-targets 0.42.2",
+ "windows-result",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7972,22 +9147,16 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.42.2"
+name = "windows-sys"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -8007,26 +9176,20 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.5",
- "windows_aarch64_msvc 0.52.5",
- "windows_i686_gnu 0.52.5",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
  "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.5",
- "windows_x86_64_gnu 0.52.5",
- "windows_x86_64_gnullvm 0.52.5",
- "windows_x86_64_msvc 0.52.5",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
@@ -8035,15 +9198,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -8053,15 +9210,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -8071,21 +9222,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -8095,15 +9240,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -8113,15 +9252,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -8131,15 +9264,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -8149,15 +9276,15 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.5.40"
+version = "0.6.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
 dependencies = [
  "memchr",
 ]
@@ -8178,83 +9305,6 @@ version = "0.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
 
-[[package]]
-name = "winter-air"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef91b335c5fefa4e6d3c6274de75a7744b4eecae2d7ee3778c23570f35f83396"
-dependencies = [
- "winter-crypto",
- "winter-fri",
- "winter-math",
- "winter-utils",
-]
-
-[[package]]
-name = "winter-crypto"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bd17ea728ff42185c54dfbabaafd0b442207df6b2cc60f74c607d8c01e9c4db"
-dependencies = [
- "blake3",
- "sha3",
- "winter-math",
- "winter-utils",
-]
-
-[[package]]
-name = "winter-fri"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2473f8b2c5c553e9f9d4d94b3b7a1e75806b4cdc964004f9bde4b5fc07c10c87"
-dependencies = [
- "winter-crypto",
- "winter-math",
- "winter-utils",
-]
-
-[[package]]
-name = "winter-math"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824b459961e5d679a1eb62ec1a71c85ac25c5d3bfd126874fcd32b591202d896"
-dependencies = [
- "winter-utils",
-]
-
-[[package]]
-name = "winter-prover"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3831583fd662f49f23ea39427aba20a9b5ab6326230f7994e843d2bd34524411"
-dependencies = [
- "log",
- "winter-air",
- "winter-crypto",
- "winter-fri",
- "winter-math",
- "winter-utils",
-]
-
-[[package]]
-name = "winter-utils"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f0dbf7ca6aa5893b59928718bf1e7dbe7279bb277b5aa4c4898ddf5004f9417"
-
-[[package]]
-name = "winter-verifier"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "922be4651b76aa80e132386a97d23788e2bc542d37b3c187a39998876a8094b6"
-dependencies = [
- "winter-air",
- "winter-crypto",
- "winter-fri",
- "winter-math",
- "winter-utils",
-]
-
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -8281,6 +9331,12 @@ version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "213b7324336b53d2414b2db8537e56544d981803139155afa84f76eeebb7a546"
 
+[[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
 [[package]]
 name = "yaml-rust"
 version = "0.4.5"
@@ -8296,31 +9352,38 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
 
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
 [[package]]
 name = "zerocopy"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
 dependencies = [
  "zeroize_derive",
 ]
@@ -8333,5 +9396,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.65",
+ "syn 2.0.79",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index ae06a4828c1..760055fc845 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,38 +26,208 @@ members = [
     "swayfmt",
     "test",
 ]
-exclude = [
-    "examples/*",
-    "swayfmt/test_macros",
-    "forc-test/test_data"
-]
+exclude = ["examples/*", "swayfmt/test_macros", "forc-test/test_data"]
+
+[workspace.package]
+edition = "2021"
+version = "0.66.2"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+homepage = "https://fuel.network/"
+license = "Apache-2.0"
+repository = "https://github.com/FuelLabs/sway"
 
 [workspace.dependencies]
-# Dependencies from the `fuel-core` repository:
-fuel-core-client = { version = "0.27.0", default-features = false }
-fuel-core-types = { version = "0.27.0", default-features = false }
+#
+# Internal dependencies in order to propagate `workspace.version`
+#
 
-# Dependencies from the `fuel-vm` repository:
-fuel-asm = "0.50.0"
-fuel-crypto = "0.50.0"
-fuel-types = "0.50.0"
-fuel-tx = "0.50.0"
-fuel-vm = "0.50.0"
+forc = { path = "forc/", version = "0.66.2" }
+forc-pkg = { path = "forc-pkg/", version = "0.66.2" }
+forc-test = { path = "forc-test/", version = "0.66.2" }
+forc-tracing = { path = "forc-tracing/", version = "0.66.2" }
+forc-util = { path = "forc-util/", version = "0.66.2" }
 
-# Dependencies from the `fuels-rs` repository:
-fuels-core = "0.63.0"
-fuels-accounts = "0.63.0"
+# Forc plugins
+forc-plugins = { path = "forc-plugins/", version = "0.66.2" }
+forc-client = { path = "forc-plugins/forc-client/", version = "0.66.2" }
+forc-crypto = { path = "forc-plugins/forc-crypto/", version = "0.66.2" }
+forc-debug = { path = "forc-plugins/forc-debug/", version = "0.66.2" }
+forc-doc = { path = "forc-plugins/forc-doc/", version = "0.66.2" }
+forc-fmt = { path = "forc-plugins/forc-fmt/", version = "0.66.2" }
+forc-lsp = { path = "forc-plugins/forc-lsp/", version = "0.66.2" }
+forc-tx = { path = "forc-plugins/forc-tx/", version = "0.66.2" }
 
-# Dependencies from the `forc-wallet` repository:
-forc-wallet = "0.8.0"
+sway-ast = { path = "sway-ast/", version = "0.66.2" }
+sway-core = { path = "sway-core/", version = "0.66.2" }
+sway-error = { path = "sway-error/", version = "0.66.2" }
+sway-lsp = { path = "sway-lsp/", version = "0.66.2" }
+sway-parse = { path = "sway-parse/", version = "0.66.2" }
+sway-types = { path = "sway-types/", version = "0.66.2" }
+sway-utils = { path = "sway-utils/", version = "0.66.2" }
+swayfmt = { path = "swayfmt/", version = "0.66.2" }
+
+# Sway IR
+sway-ir = { path = "sway-ir/", version = "0.66.2" }
+sway-ir-macros = { path = "sway-ir/sway-ir-macros", version = "0.66.2" }
+
+#
+# External Fuel dependencies
+#
 
 # Dependencies from the `fuel-abi-types` repository:
-fuel-abi-types = "0.5.0"
+fuel-abi-types = "0.7"
 
-[workspace.package]
-edition = "2021"
-authors = ["Fuel Labs <contact@fuel.sh>"]
-homepage = "https://fuel.network/"
-license = "Apache-2.0"
-repository = "https://github.com/FuelLabs/sway"
+# Dependencies from the `fuel-core` repository:
+#
+# Although ALL verions are "X.Y", we need the complete semver for
+# fuel-core-client as the GitHub Actions workflow parses this value to pull down
+# the correct tarball
+fuel-core-client = { version = "0.40.0", default-features = false }
+fuel-core-types = { version = "0.40", default-features = false }
+
+# Dependencies from the `fuels-rs` repository:
+
+fuels = "0.66.9"
+fuels-core = "0.66.9"
+fuels-accounts = "0.66.9"
+
+# Dependencies from the `fuel-vm` repository:
+fuel-asm = "0.58"
+fuel-crypto = "0.58"
+fuel-types = "0.58"
+fuel-tx = "0.58"
+fuel-vm = "0.58"
+
+# Dependencies from the `forc-wallet` repository:
+forc-wallet = "0.11"
+
+#
+# External dependencies
+#
 
+annotate-snippets = "0.10"
+ansi_term = "0.12"
+anyhow = "1.0"
+assert-json-diff = "2.0"
+async-trait = "0.1"
+atty = "0.2"
+aws-config = "1.5"
+aws-sdk-kms = "1.44"
+byte-unit = "5.1"
+bytecount = "0.6"
+bytes = "1.7"
+chrono = { version = "0.4", default-features = false }
+cid = "0.11"
+clap = "4.5"
+clap_complete = "4.5"
+clap_complete_fig = "4.5"
+colored = "2.0"
+comrak = "0.28"
+crossbeam-channel = "0.5"
+dap = "0.4.1-alpha"
+dashmap = "6.1"
+derivative = "2.2"
+devault = "0.2"
+dialoguer = "0.11"
+dirs = "5.0"
+downcast-rs = "1.2"
+either = "1.9"
+ethabi = { package = "fuel-ethabi", version = "18.0" }
+etk-asm = { package = "fuel-etk-asm", version = "0.3.1-dev" }
+etk-ops = { package = "fuel-etk-ops", version = "0.3.1-dev" }
+extension-trait = "1.0"
+fd-lock = "4.0"
+filecheck = "0.5"
+fs_extra = "1.2"
+futures = { version = "0.3", default-features = false }
+gag = "1.0"
+gimli = "0.31"
+git2 = "0.19"
+gix-url = "0.27"
+glob = "0.3"
+graph-cycles = "0.1"
+hashbrown = "0.14"
+hex = "0.4"
+horrorshow = "0.8"
+im = "15.0"
+in_definite = "1.0"
+include_dir = "0.7"
+indexmap = "2.5"
+indoc = "2.0"
+insta = "1.40"
+ipfs-api-backend-hyper = "0.6"
+itertools = "0.13"
+k256 = "0.13"
+lazy_static = "1.4"
+libp2p-identity = "0.2"
+libtest-mimic = "0.7"
+lsp-types = "0.94"
+mdbook = { version = "0.4", default-features = false }
+minifier = "0.3"
+notify = "6.1"
+notify-debouncer-mini = "0.4"
+num-bigint = "0.4"
+num-traits = "0.2"
+object = "0.36"
+once_cell = "1.18"
+opener = "0.7"
+parking_lot = "0.12"
+paste = "1.0"
+peg = "0.8"
+pest = "2.7"
+pest_derive = "2.7"
+petgraph = "0.6"
+phf = "0.11"
+pretty_assertions = "1.4"
+prettydiff = "0.7"
+proc-macro2 = "1.0"
+quote = "1.0"
+rand = "0.8"
+rayon = "1.7"
+rayon-cond = "0.3"
+regex = "1.10"
+reqwest = "0.12"
+revm = "14.0"
+ropey = "1.5"
+rpassword = "7.2"
+rustc-hash = "1.1"
+semver = "1.0"
+serde = "1.0"
+serde_ignored = "0.1"
+serde_json = "1.0"
+serde_with = "3.3"
+serde_yaml = "0.9"
+serial_test = "3.0"
+sha2 = "0.10"
+sha3 = "0.10"
+shellfish = "0.9"
+slotmap = "1.0"
+smallvec = "1.7"
+strsim = "0.11"
+strum = "0.26"
+syn = "2.0"
+taplo = "0.13"
+tar = "0.4"
+tempfile = "3"
+term-table = "1.3"
+termion = "4.0"
+textwrap = "0.16"
+thiserror = "1.0"
+tikv-jemallocator = "0.6"
+tokio = "1.12"
+toml = "0.8"
+toml_edit = "0.22"
+tower = { version = "0.5", default-features = false }
+tower-lsp = "0.20"
+tracing = "0.1"
+tracing-subscriber = "0.3"
+uint = "0.9"
+unicode-bidi = "0.3"
+unicode-xid = "0.2"
+url = "2.2"
+urlencoding = "2.1"
+uwuify = "^0.2"
+vec1 = "1.8"
+vte = "0.13"
+walkdir = "2.3"
+whoami = "1.5"
diff --git a/README.md b/README.md
index 14eb838f01f..737fb61ebc7 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 [![docs](https://docs.rs/forc/badge.svg)](https://docs.rs/forc/)
 [![discord](https://img.shields.io/badge/chat%20on-discord-orange?&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/xfpK4Pe)
 
-Sway is a language developed for the Fuel blockchain. It is heavily inspired by Rust and aims to bring modern language development and performance to the blockchain ecosystem.
+Sway is a language developed for the [Fuel](https://docs.fuel.network/docs/intro/what-is-fuel/) blockchain. It is heavily inspired by Rust and aims to bring modern language development and performance to the blockchain ecosystem.
 
 ## Documentation
 
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000000..dab1c5c4c2c
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,31 @@
+# Fuel Security Policy
+
+Thank you for helping make the Fuel ecosystem safe for everyone. The Fuel team take security bugs very seriously. We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions.
+
+## Reporting Security Issues
+
+If you believe you have found a security vulnerability in any Fuel-owned repository, please report it to us through coordinated disclosure.
+
+**Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.**
+
+Instead, please use the GitHub Security Advisory ["Report a Vulnerability"](https://github.com/FuelLabs/sway/security/advisories/new) tab.
+
+The Fuel team will send a response indicating the next steps in handling your report. After the initial reply to your report, the team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
+
+Please include as much of the information listed below as you can to help us better understand and resolve the issue:
+
+* The type of issue (e.g., buffer overflow, SQL injection, or cross-site scripting)
+* Full paths of source file(s) related to the manifestation of the issue
+* The location of the affected source code (tag/branch/commit or direct URL)
+* Any special configuration required to reproduce the issue
+* Step-by-step instructions to reproduce the issue
+* Proof-of-concept or exploit code (if possible)
+* Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+Report security bugs in third-party modules to the person or team maintaining the module.
+
+## Non-Security Issues
+
+If the issue is not security-related, please report it publicly by opening a [GitHub Issue](https://github.com/FuelLabs/sway/issues/new).
diff --git a/deployment/Dockerfile b/deployment/Dockerfile
index a9b865856af..10868781760 100644
--- a/deployment/Dockerfile
+++ b/deployment/Dockerfile
@@ -1,5 +1,5 @@
 # Stage 1: Build
-FROM lukemathwalker/cargo-chef:latest-rust-1.76 as chef
+FROM lukemathwalker/cargo-chef:latest-rust-1.79 as chef
 WORKDIR /build/
 # hadolint ignore=DL3008
 RUN apt-get update && \
diff --git a/docs/book/spell-check-custom-words.txt b/docs/book/spell-check-custom-words.txt
index 818c9a71b02..6e18232eaf0 100644
--- a/docs/book/spell-check-custom-words.txt
+++ b/docs/book/spell-check-custom-words.txt
@@ -4,6 +4,7 @@ ASM
 IDE
 IDEs
 LSP
+lsp
 namespace
 ALU
 APIs
@@ -210,4 +211,20 @@ namespacing
 unsafety
 prioritizations
 polymorphism
-ContractId
\ No newline at end of file
+ContractId
+booleans
+underflows
+Codec
+bool
+str
+multisig
+addr
+addr2line
+contract-id
+init
+parse-bytecode
+predicate-root
+forc-client
+crypto
+doc
+fmt
\ No newline at end of file
diff --git a/docs/book/src/SUMMARY.md b/docs/book/src/SUMMARY.md
index 78f0164d676..262437ea2cc 100644
--- a/docs/book/src/SUMMARY.md
+++ b/docs/book/src/SUMMARY.md
@@ -7,6 +7,7 @@
   - [The Fuel Toolchain](./introduction/fuel_toolchain.md)
   - [A Forc Project](./introduction/forc_project.md)
   - [Standard Library](./introduction/standard_library.md)
+  - [Core Library](./introduction/core_library.md)
   - [Sway Language Standards](./introduction/sway_standards.md)
 - [Examples](./examples/index.md)
   - [Counter](./examples/counter.md)
@@ -69,6 +70,7 @@
   - [Attributes](./reference/attributes.md)
   - [Style Guide](./reference/style_guide.md)
   - [Known Issues and Workarounds](./reference/known_issues_and_workarounds.md)
+  - [Behavior Considered Undefined](./reference/undefined_behavior.md)
   - [Differences From Solidity](./reference/solidity_differences.md)
   - [Differences From Rust](./reference/rust_differences.md)
   - [Contributing To Sway](./reference/contributing_to_sway.md)
@@ -78,28 +80,28 @@
   - [Workspaces](./forc/workspaces.md)
   - [Dependencies](./forc/dependencies.md)
   - [Commands](./forc/commands/index.md)
-    - [`forc addr2line`](./forc/commands/forc_addr2line.md)
-    - [`forc build`](./forc/commands/forc_build.md)
-    - [`forc check`](./forc/commands/forc_check.md)
-    - [`forc clean`](./forc/commands/forc_clean.md)
-    - [`forc completions`](./forc/commands/forc_completions.md)
-    - [`forc contract-id`](./forc/commands/forc_contract-id.md)
-    - [`forc init`](./forc/commands/forc_init.md)
-    - [`forc new`](./forc/commands/forc_new.md)
-    - [`forc parse-bytecode`](./forc/commands/forc_parse-bytecode.md)
-    - [`forc plugins`](./forc/commands/forc_plugins.md)
-    - [`forc predicate-root`](./forc/commands/forc_predicate-root.md)
-    - [`forc test`](./forc/commands/forc_test.md)
-    - [`forc update`](./forc/commands/forc_update.md)
-    - [`forc template`](./forc/commands/forc_template.md)
+    - [forc addr2line](./forc/commands/forc_addr2line.md)
+    - [forc build](./forc/commands/forc_build.md)
+    - [forc check](./forc/commands/forc_check.md)
+    - [forc clean](./forc/commands/forc_clean.md)
+    - [forc completions](./forc/commands/forc_completions.md)
+    - [forc contract-id](./forc/commands/forc_contract-id.md)
+    - [forc init](./forc/commands/forc_init.md)
+    - [forc new](./forc/commands/forc_new.md)
+    - [forc parse-bytecode](./forc/commands/forc_parse-bytecode.md)
+    - [forc plugins](./forc/commands/forc_plugins.md)
+    - [forc predicate-root](./forc/commands/forc_predicate-root.md)
+    - [forc test](./forc/commands/forc_test.md)
+    - [forc update](./forc/commands/forc_update.md)
+    - [forc template](./forc/commands/forc_template.md)
   - [Plugins](./forc/plugins/index.md)
-    - [`forc client`](./forc/plugins/forc_client/index.md)
-      - [`forc deploy`](./forc/plugins/forc_client/forc_deploy.md)
-      - [`forc run`](./forc/plugins/forc_client/forc_run.md)
-      - [`forc submit`](./forc/plugins/forc_client/forc_submit.md)
-    - [`forc crypto`](./forc/plugins/forc_crypto.md)
-    - [`forc debug`](./forc/plugins/forc_debug.md)
-    - [`forc doc`](./forc/plugins/forc_doc.md)
-    - [`forc explore`](./forc/plugins/forc_explore.md)
-    - [`forc fmt`](./forc/plugins/forc_fmt.md)
-    - [`forc lsp`](./forc/plugins/forc_lsp.md)
+    - [forc client](./forc/plugins/forc_client/index.md)
+      - [forc deploy](./forc/plugins/forc_client/forc_deploy.md)
+      - [forc run](./forc/plugins/forc_client/forc_run.md)
+      - [forc submit](./forc/plugins/forc_client/forc_submit.md)
+    - [forc crypto](./forc/plugins/forc_crypto.md)
+    - [forc debug](./forc/plugins/forc_debug.md)
+    - [forc doc](./forc/plugins/forc_doc.md)
+    - [forc explore](./forc/plugins/forc_explore.md)
+    - [forc fmt](./forc/plugins/forc_fmt.md)
+    - [forc lsp](./forc/plugins/forc_lsp.md)
diff --git a/docs/book/src/advanced/assembly.md b/docs/book/src/advanced/assembly.md
index 3bad77ecab6..31d323f5a4d 100644
--- a/docs/book/src/advanced/assembly.md
+++ b/docs/book/src/advanced/assembly.md
@@ -1,6 +1,6 @@
 # Inline Assembly in Sway
 
-While many users will never have to touch assembly language while writing sway code, it is a powerful tool that enables many advanced use-cases (e.g., optimizations, building libraries, etc).
+While many users will never have to touch assembly language while writing Sway code, it is a powerful tool that enables many advanced use-cases (e.g., optimizations, building libraries, etc).
 
 ## ASM Block
 
@@ -11,7 +11,7 @@ asm() {...}
 ```
 
 Declaring an `asm` block is similar to declaring a function.
-We can specify register names to operate on as arguments, we can perform operations within the block, and we can return a value.
+We can specify register names to operate on as arguments, we can perform assembly instructions within the block, and we can return a value by specifying a return register.
 Here's an example showing what this might look like:
 
 ```sway
@@ -23,7 +23,12 @@ pub fn add_1(num: u32) -> u32 {
 }
 ```
 
-An `asm` block can only return a single register. If you really need to return more than one value, you can modify a tuple. Here's an example showing how you can implement this `(u64, u64)`:
+The return register is specified at the end of the `asm` block, after all the assembly instructions. It consists of the register name and an optional return type. In the above example, the return register name is `r2` and the return type is `u32`.
+If the return type is omitted, it is `u64` by default.
+
+The return register itself is optional. If it is not specified, similar to functions, the returned value from the `asm` block will be [unit](../basics/built_in_types.md#unit-type), `()`.
+
+An `asm` block can only return a single register. If you really need to return more than one value, you can modify a tuple. Here's an example showing how you can implement this for `(u64, u64)`:
 
 ```sway
 {{#include ../../../../examples/asm_return_tuple_pointer/src/main.sw}}
@@ -37,7 +42,7 @@ Note that in the above example:
 - we declared a second register `r2` (you may choose any register names you want).
 - we use the `add` opcode to add `one` to the value of `r1` and store it in `r2`.
 - `one` is an example of a "reserved register", of which there are 16 in total. Further reading on this is linked below under "Semantics".
-- we return `r2` & specify the return type as being u32 (the return type is u64 by default).
+- we return `r2` and specify the return type as being `u32`.
 
 An important note is that the `ji` and `jnei` opcodes are not available within an `asm` block. For those looking to introduce control flow to `asm` blocks, it is recommended to surround smaller chunks of `asm` with control flow (`if`, `else`, and `while`).
 
diff --git a/docs/book/src/basics/built_in_types.md b/docs/book/src/basics/built_in_types.md
index ddfbb7b233b..e7798a803b0 100644
--- a/docs/book/src/basics/built_in_types.md
+++ b/docs/book/src/basics/built_in_types.md
@@ -13,6 +13,7 @@ Sway is a statically typed language. At compile time, the types of every value m
 <!-- prim_types:example:start -->
 Sway has the following primitive types:
 
+1. `()` (unit type)
 1. `u8` (8-bit unsigned integer)
 1. `u16` (16-bit unsigned integer)
 1. `u32` (32-bit unsigned integer)
@@ -26,6 +27,25 @@ Sway has the following primitive types:
 All other types in Sway are built up of these primitive types, or references to these primitive types. You may notice that there are no signed integers&mdash;this is by design. In the blockchain domain that Sway occupies, floating-point values and negative numbers have smaller utility, so their implementation has been left up to libraries for specific use cases.
 <!-- prim_types:example:end -->
 
+## Unit Type
+
+The unit type, `()`, is a type that allows only one value, and thus, represents a value with no information. It is used to indicate the absence of a meaningful value, or the result of a function that performs an action, but does not return any data. The value of the unit type, called simply unit, has the same symbol as the unit type, `()`. Unit type in Sway serves a similar purpose as `void` in imperative languages like C or Java.
+
+For example:
+
+```Sway
+fn returns_unit() -> () { // Here, `()` represent the unit type.
+    ()                    // Here, `()` represents the single unit value of the unit type.
+}
+```
+
+In Sway, if the function return type is not specified, it is `()` by default. Thus, the above example is semantically same as the following:
+
+```Sway
+fn returns_unit() {
+}
+```
+
 ## Numeric Types
 
 All of the unsigned integer types are numeric types.
diff --git a/docs/book/src/blockchain-development/native_assets.md b/docs/book/src/blockchain-development/native_assets.md
index 4cfc33fb029..7f1298326f9 100644
--- a/docs/book/src/blockchain-development/native_assets.md
+++ b/docs/book/src/blockchain-development/native_assets.md
@@ -199,9 +199,21 @@ It implements the [SRC-20; Native Asset](https://github.com/FuelLabs/sway-standa
 // ERC20 equivalent in Sway.
 contract;
 
-use src3::SRC3;
-use src5::{SRC5, State, AccessError};
-use src20::SRC20;
+use standards::{
+    src3::SRC3,
+    src5::{
+        SRC5, 
+        State, 
+        AccessError,
+    },
+    src20::{
+        SetDecimalsEvent, 
+        SetNameEvent, 
+        SetSymbolEvent, 
+        SRC20, 
+        TotalSupplyEvent,
+    },
+};
 use std::{
     asset::{
         burn,
@@ -280,14 +292,21 @@ impl SRC5 for Contract {
 // Mint and Burn Standard
 impl SRC3 for Contract {
     #[storage(read, write)]
-    fn mint(recipient: Identity, sub_id: SubId, amount: u64) {
-        require(sub_id == DEFAULT_SUB_ID, "incorrect-sub-id");
+    fn mint(recipient: Identity, sub_id: Option<SubId>, amount: u64) {
+        require(sub_id.is_some() && sub_id.unwrap() == DEFAULT_SUB_ID, "incorrect-sub-id");
         require_access_owner();
 
+        let new_supply = storage.total_supply.read() + amount;
         storage
             .total_supply
-            .write(amount + storage.total_supply.read());
+            .write(new_supply);
         mint_to(recipient, DEFAULT_SUB_ID, amount);
+        
+        TotalSupplyEvent::new(
+            AssetId::default(), 
+            new_supply, 
+            msg_sender().unwrap()
+        ).log();
     }
 
     #[storage(read, write)]
@@ -300,10 +319,17 @@ impl SRC3 for Contract {
         );
         require_access_owner();
 
+        let new_supply = storage.total_supply.read() - amount;
         storage
             .total_supply
-            .write(storage.total_supply.read() - amount);
+            .write(new_supply);
         burn(DEFAULT_SUB_ID, amount);
+        
+        TotalSupplyEvent::new(
+            AssetId::default(), 
+            new_supply, 
+            msg_sender().unwrap()
+        ).log();
     }
 }
 
@@ -327,6 +353,24 @@ fn require_access_owner() {
         AccessError::NotOwner,
     );
 }
+
+abi EmitSRC20Events {
+    fn emit_src20_events();
+}
+
+impl EmitSRC20Events for Contract {
+    fn emit_src20_events() {
+        // Metadata that is stored as a configurable should only be emitted once.
+        let asset = AssetId::default();
+        let sender = msg_sender().unwrap();
+        let name = Some(String::from_ascii_str(from_str_array(NAME)));
+        let symbol = Some(String::from_ascii_str(from_str_array(SYMBOL)));
+
+        SetNameEvent::new(asset, name, sender).log();
+        SetSymbolEvent::new(asset, symbol, sender).log();
+        SetDecimalsEvent::new(asset, DECIMALS, sender).log();
+    }
+}
 ```
 
 ## Multi Native Asset Example
@@ -339,9 +383,21 @@ It implements the [SRC-20; Native Asset](https://github.com/FuelLabs/sway-standa
 // ERC1155 equivalent in Sway.
 contract;
 
-use src5::{SRC5, State, AccessError};
-use src20::SRC20;
-use src3::SRC3;
+use standards::{
+    src5::{
+        SRC5, 
+        State, 
+        AccessError
+    },
+    src20::{
+        SetDecimalsEvent, 
+        SetNameEvent, 
+        SetSymbolEvent, 
+        SRC20, 
+        TotalSupplyEvent,
+    }
+    src3::SRC3,
+};
 use std::{
     asset::{
         burn,
@@ -397,28 +453,42 @@ impl SRC20 for Contract {
 // Mint and Burn Standard
 impl SRC3 for Contract {
     #[storage(read, write)]
-    fn mint(recipient: Identity, sub_id: SubId, amount: u64) {
+    fn mint(recipient: Identity, sub_id: Option<SubId>, amount: u64) {
+        require(sub_id.is_some(), "Error: SubId is None");
         require_access_owner();
-        let asset_id = AssetId::new(contract_id(), sub_id);
+
+        let asset_id = AssetId::new(ContractId::this(), sub_id.unwrap());
         let supply = storage.total_supply.get(asset_id).try_read();
         if supply.is_none() {
             storage.total_assets.write(storage.total_assets.try_read().unwrap_or(0) + 1);
         }
-        let current_supply = supply.unwrap_or(0);
-        storage.total_supply.insert(asset_id, current_supply + amount);
+        let new_supply = supply.unwrap_or(0) + amount;
+        storage.total_supply.insert(asset_id, new_supply);
         mint_to(recipient, sub_id, amount);
+        
+        TotalSupplyEvent::new(
+            asset_id, 
+            new_supply, 
+            msg_sender().unwrap()
+        ).log();
     }
     
     #[storage(read, write)]
     fn burn(sub_id: SubId, amount: u64) {
         require_access_owner();
-        let asset_id = AssetId::new(contract_id(), sub_id);
+        let asset_id = AssetId::new(ContractId::this(), sub_id);
         require(this_balance(asset_id) >= amount, "not-enough-coins");
         
         let supply = storage.total_supply.get(asset_id).try_read();
-        let current_supply = supply.unwrap_or(0);
-        storage.total_supply.insert(asset_id, current_supply - amount);
+        let new_supply = supply.unwrap_or(0) - amount;
+        storage.total_supply.insert(asset_id, new_supply);
         burn(sub_id, amount);
+
+        TotalSupplyEvent::new(
+            asset_id, 
+            new_supply, 
+            msg_sender().unwrap()
+        ).log();
     }
 }
 
@@ -427,10 +497,10 @@ abi MultiAsset {
     fn constructor(owner_: Identity);
     
     #[storage(read, write)]
-    fn set_name(asset: AssetId, name: String);
+    fn set_name(asset: AssetId, name: Option<String>);
 
     #[storage(read, write)]
-    fn set_symbol(asset: AssetId, symbol: String);
+    fn set_symbol(asset: AssetId, symbol: Option<String>);
 
     #[storage(read, write)]
     fn set_decimals(asset: AssetId, decimals: u8);
@@ -444,23 +514,29 @@ impl MultiAsset for Contract {
     }
     
     #[storage(read, write)]
-    fn set_name(asset: AssetId, name: String) {
+    fn set_name(asset: AssetId, name: Option<String>) {
         require_access_owner();
         storage.name.insert(asset, StorageString {});
         storage.name.get(asset).write_slice(name);
+
+        SetNameEvent::new(asset, name, msg_sender().unwrap()).log();
     }
 
     #[storage(read, write)]
-    fn set_symbol(asset: AssetId, symbol: String) {
+    fn set_symbol(asset: AssetId, symbol: Option<String>) {
         require_access_owner();
         storage.symbol.insert(asset, StorageString {});
         storage.symbol.get(asset).write_slice(symbol);
+
+        SetSymbolEvent::new(asset, symbol, msg_sender().unwrap()).log();
     }
 
     #[storage(read, write)]
     fn set_decimals(asset: AssetId, decimals: u8) {
         require_access_owner();
         storage.decimals.insert(asset, decimals);
+
+        SetDecimalsEvent::new(asset, decimals, msg_sender().unwrap()).log();
     }
 }
 
diff --git a/docs/book/src/blockchain-development/purity.md b/docs/book/src/blockchain-development/purity.md
index b6ba55a54a8..35149ecfd74 100644
--- a/docs/book/src/blockchain-development/purity.md
+++ b/docs/book/src/blockchain-development/purity.md
@@ -5,6 +5,8 @@
 A function is _pure_ if it does not access any [persistent storage](./storage.md). Conversely, the function is _impure_ if it does access any storage. Naturally, as storage is only available in smart contracts, impure functions cannot be used in predicates, scripts, or libraries. A pure function cannot call an impure function.
 
 In Sway, functions are pure by default but can be opted into impurity via the `storage` function attribute. The `storage` attribute may take `read` and/or `write` arguments indicating which type of access the function requires.
+
+The `storage` attribute without any arguments, `#[storage()]`, indicates a pure function, and has the same effect as not having the attribute at all.
 <!-- pure:example:end -->
 
 ```sway
@@ -17,6 +19,15 @@ fn get_amount() -> u64 {
 fn increment_amount(increment: u64) -> u64 {
     ...
 }
+
+fn a_pure_function() {
+    ...
+}
+
+#[storage()]
+fn also_a_pure_function() {
+    ...
+}
 ```
 
 > **Note**: the `#[storage(write)]` attribute also permits a function to read from storage. This is due to the fact that partially writing a storage slot requires first reading the slot.
@@ -31,6 +42,8 @@ The `storage` attribute may also be applied to [methods and associated functions
 <!-- This section should explain the benefits of using pure functions in Sway -->
 <!-- pure_benefits:example:start -->
 A pure function gives you some guarantees: you will not incur excessive storage gas costs, the compiler can apply additional optimizations, and they are generally easy to reason about and audit.
+
+> **Note**: Purity does not provide an absolute guarantee that a storage access will not happen as a result of calling a pure function. E.g., it is possible for a pure function to call another contract, which can then call a write function in the original contract. The guarantee that the purity gives in this example is, that the original pure function itself does not change the storage, as well as that any function later called, that accesses storage, is clearly marked as impure.
 <!-- pure_benefits:example:end -->
 
 [A similar concept exists in Solidity](https://docs.soliditylang.org/en/v0.8.10/contracts.html#pure-functions). Note that Solidity refers to contract storage as _contract state_, and in the Sway/Fuel ecosystem, these two terms are largely interchangeable.
diff --git a/docs/book/src/debugging/debugging_with_cli.md b/docs/book/src/debugging/debugging_with_cli.md
index fd02bd5c2e2..740eb3e5bc3 100644
--- a/docs/book/src/debugging/debugging_with_cli.md
+++ b/docs/book/src/debugging/debugging_with_cli.md
@@ -83,46 +83,193 @@ Now we would like to inspect the program while it's running. To do this, we firs
 
 ```json
 {
-    "Script": {
-        "script_gas_limit": 1000000,
-        "script": [],
-        "script_data": [],
-        "policies": {
-            "bits": "GasPrice",
-            "values": [0,0,0,0]
-        },
-        "inputs": [
-            {
-                "CoinSigned": {
-                    "utxo_id": {
-                        "tx_id": "c49d65de61cf04588a764b557d25cc6c6b4bc0d7429227e2a21e61c213b3a3e2",
-                        "output_index": 18
-                    },
-                    "owner": "f1e92c42b90934aa6372e30bc568a326f6e66a1a0288595e6e3fbd392a4f3e6e",
-                    "amount": 10599410012256088338,
-                    "asset_id": "2cafad611543e0265d89f1c2b60d9ebf5d56ad7e23d9827d6b522fd4d6e44bc3",
-                    "tx_pointer": {
-                        "block_height": 0,
-                        "tx_index": 0
-                    },
-                    "witness_index": 0,
-                    "maturity": 0,
-                    "predicate_gas_used": null,
-                    "predicate": null,
-                    "predicate_data": null
-                }
-            }
-        ],
-        "outputs": [],
-        "witnesses": [
-            {
-                "data": [
-                    156,254,34,102,65,96,133,170,254,105,147,35,196,199,179,133,132,240,208,149,11,46,30,96,44,91,121,195,145,184,159,235,117,82,135,41,84,154,102,61,61,16,99,123,58,173,75,226,219,139,62,33,41,176,16,18,132,178,8,125,130,169,32,108
-                ]
-            }
-        ],
-        "receipts_root": "0000000000000000000000000000000000000000000000000000000000000000"
-    }
+  "Script": {
+    "body": {
+      "script_gas_limit": 1000000,
+      "script": [
+        144,
+        0,
+        0,
+        4,
+        71,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        68,
+        93,
+        252,
+        192,
+        1,
+        16,
+        255,
+        243,
+        0,
+        26,
+        72,
+        16,
+        0,
+        26,
+        68,
+        0,
+        0,
+        93,
+        67,
+        240,
+        0,
+        22,
+        65,
+        20,
+        0,
+        115,
+        64,
+        0,
+        13,
+        51,
+        72,
+        0,
+        0,
+        36,
+        0,
+        0,
+        0,
+        16,
+        69,
+        16,
+        64,
+        27,
+        73,
+        36,
+        64,
+        144,
+        0,
+        0,
+        8,
+        71,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        5
+      ],
+      "script_data": [],
+      "receipts_root": "0000000000000000000000000000000000000000000000000000000000000000"
+    },
+    "policies": {
+      "bits": "MaxFee",
+      "values": [
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    "inputs": [
+      {
+        "CoinSigned": {
+          "utxo_id": {
+            "tx_id": "c49d65de61cf04588a764b557d25cc6c6b4bc0d7429227e2a21e61c213b3a3e2",
+            "output_index": 18
+          },
+          "owner": "f1e92c42b90934aa6372e30bc568a326f6e66a1a0288595e6e3fbd392a4f3e6e",
+          "amount": 10599410012256088000,
+          "asset_id": "2cafad611543e0265d89f1c2b60d9ebf5d56ad7e23d9827d6b522fd4d6e44bc3",
+          "tx_pointer": {
+            "block_height": 0,
+            "tx_index": 0
+          },
+          "witness_index": 0,
+          "maturity": 0,
+          "predicate_gas_used": null,
+          "predicate": null,
+          "predicate_data": null
+        }
+      }
+    ],
+    "outputs": [],
+    "witnesses": [
+      {
+        "data": [
+          156,
+          254,
+          34,
+          102,
+          65,
+          96,
+          133,
+          170,
+          254,
+          105,
+          147,
+          35,
+          196,
+          199,
+          179,
+          133,
+          132,
+          240,
+          208,
+          149,
+          11,
+          46,
+          30,
+          96,
+          44,
+          91,
+          121,
+          195,
+          145,
+          184,
+          159,
+          235,
+          117,
+          82,
+          135,
+          41,
+          84,
+          154,
+          102,
+          61,
+          61,
+          16,
+          99,
+          123,
+          58,
+          173,
+          75,
+          226,
+          219,
+          139,
+          62,
+          33,
+          41,
+          176,
+          16,
+          18,
+          132,
+          178,
+          8,
+          125,
+          130,
+          169,
+          32,
+          108
+        ]
+      }
+    ]
+  }
 }
 ```
 
diff --git a/docs/book/src/examples/counter.md b/docs/book/src/examples/counter.md
index ef3079cc8bf..a9850f24742 100644
--- a/docs/book/src/examples/counter.md
+++ b/docs/book/src/examples/counter.md
@@ -9,3 +9,15 @@ forc template --template-name counter my_counter_project
 ```sway
 {{#include ../../../../examples/counter/src/main.sw}}
 ```
+
+## Build and deploy
+
+The following commands can be used to build and deploy the contract. For a detailed tutorial, refer to [Building and Deploying](https://docs.fuel.network/guides/contract-quickstart/#building-the-contract).
+
+```bash
+# Build the contract
+forc build
+
+# Deploy the contract
+forc deploy --testnet
+```
diff --git a/docs/book/src/forc/commands/forc_addr2line.md b/docs/book/src/forc/commands/forc_addr2line.md
index cd1835e1c49..9da1be10b3f 100644
--- a/docs/book/src/forc/commands/forc_addr2line.md
+++ b/docs/book/src/forc/commands/forc_addr2line.md
@@ -1 +1 @@
-# `forc addr2line`
+# forc addr2line
diff --git a/docs/book/src/forc/commands/forc_build.md b/docs/book/src/forc/commands/forc_build.md
index 950396b5f28..f7285039bd7 100644
--- a/docs/book/src/forc/commands/forc_build.md
+++ b/docs/book/src/forc/commands/forc_build.md
@@ -1 +1 @@
-# `forc build`
+# forc build
diff --git a/docs/book/src/forc/commands/forc_check.md b/docs/book/src/forc/commands/forc_check.md
index 88bd1757b61..49f24c6bc70 100644
--- a/docs/book/src/forc/commands/forc_check.md
+++ b/docs/book/src/forc/commands/forc_check.md
@@ -1 +1 @@
-# `forc check`
+# forc check
diff --git a/docs/book/src/forc/commands/forc_clean.md b/docs/book/src/forc/commands/forc_clean.md
index 5ce65cb93c3..bbe1d3db337 100644
--- a/docs/book/src/forc/commands/forc_clean.md
+++ b/docs/book/src/forc/commands/forc_clean.md
@@ -1 +1 @@
-# `forc clean`
+# forc clean
diff --git a/docs/book/src/forc/commands/forc_completions.md b/docs/book/src/forc/commands/forc_completions.md
index 309573d4870..91ae73c0015 100644
--- a/docs/book/src/forc/commands/forc_completions.md
+++ b/docs/book/src/forc/commands/forc_completions.md
@@ -1 +1 @@
-# `forc completions`
+# forc completions
diff --git a/docs/book/src/forc/commands/forc_contract-id.md b/docs/book/src/forc/commands/forc_contract-id.md
index 81c0f140465..f6c47b041e2 100644
--- a/docs/book/src/forc/commands/forc_contract-id.md
+++ b/docs/book/src/forc/commands/forc_contract-id.md
@@ -1 +1 @@
-# `forc contract-id`
+# forc contract-id
diff --git a/docs/book/src/forc/commands/forc_init.md b/docs/book/src/forc/commands/forc_init.md
index 0a5ba539d84..9931411557d 100644
--- a/docs/book/src/forc/commands/forc_init.md
+++ b/docs/book/src/forc/commands/forc_init.md
@@ -1 +1 @@
-# `forc init`
+# forc init
diff --git a/docs/book/src/forc/commands/forc_new.md b/docs/book/src/forc/commands/forc_new.md
index 58fd660c119..0e6e939318c 100644
--- a/docs/book/src/forc/commands/forc_new.md
+++ b/docs/book/src/forc/commands/forc_new.md
@@ -1 +1 @@
-# `forc new`
+# forc new
diff --git a/docs/book/src/forc/commands/forc_parse-bytecode.md b/docs/book/src/forc/commands/forc_parse-bytecode.md
index 80c67edb461..79d718cc9f7 100644
--- a/docs/book/src/forc/commands/forc_parse-bytecode.md
+++ b/docs/book/src/forc/commands/forc_parse-bytecode.md
@@ -1 +1 @@
-# `forc parse-bytecode`
+# forc parse-bytecode
diff --git a/docs/book/src/forc/commands/forc_plugins.md b/docs/book/src/forc/commands/forc_plugins.md
index bc0e7aa6c00..a6cfa94c56e 100644
--- a/docs/book/src/forc/commands/forc_plugins.md
+++ b/docs/book/src/forc/commands/forc_plugins.md
@@ -1 +1 @@
-# `forc plugins`
+# forc plugins
diff --git a/docs/book/src/forc/commands/forc_predicate-root.md b/docs/book/src/forc/commands/forc_predicate-root.md
index 9ed1d7ca56d..863450ebb50 100644
--- a/docs/book/src/forc/commands/forc_predicate-root.md
+++ b/docs/book/src/forc/commands/forc_predicate-root.md
@@ -1 +1 @@
-# `forc predicate-root`
+# forc predicate-root
diff --git a/docs/book/src/forc/commands/forc_template.md b/docs/book/src/forc/commands/forc_template.md
index 4bc677ff08c..a6cd711e7aa 100644
--- a/docs/book/src/forc/commands/forc_template.md
+++ b/docs/book/src/forc/commands/forc_template.md
@@ -1 +1 @@
-# `forc template`
+# forc template
diff --git a/docs/book/src/forc/commands/forc_test.md b/docs/book/src/forc/commands/forc_test.md
index 7c4ce2723b7..85254c0002e 100644
--- a/docs/book/src/forc/commands/forc_test.md
+++ b/docs/book/src/forc/commands/forc_test.md
@@ -1 +1 @@
-# `forc test`
+# forc test
diff --git a/docs/book/src/forc/commands/forc_update.md b/docs/book/src/forc/commands/forc_update.md
index 6805c316eed..0dcb013a3d0 100644
--- a/docs/book/src/forc/commands/forc_update.md
+++ b/docs/book/src/forc/commands/forc_update.md
@@ -1 +1 @@
-# `forc update`
+# forc update
diff --git a/docs/book/src/forc/manifest_reference.md b/docs/book/src/forc/manifest_reference.md
index 55539866850..e9be681e5c8 100644
--- a/docs/book/src/forc/manifest_reference.md
+++ b/docs/book/src/forc/manifest_reference.md
@@ -76,7 +76,6 @@ The following fields can be provided for a build-profile:
 * `terse` - Terse mode. Limited warning and error output, defaults to false.
 * `time_phases` - Whether to output the time elapsed over each part of the compilation process, defaults to false.
 * `include_tests` -  Whether or not to include test functions in parsing, type-checking, and code generation. This is set to true by invocations like `forc test`, but defaults to false.
-* `json_abi_with_callpaths` - Whether to generate a JSON ABI with `callpaths` instead of names for structs and enums, defaults to false. This option can help prevent conflicting struct or enum definitions by using the full path instead of the name.
 * `error_on_warnings` - Whether to treat errors as warnings, defaults to false.
 
 There are two default `[build-profile]` available with every manifest file. These are `debug` and `release` profiles. If you want to override these profiles, you can provide them explicitly in the manifest file like the following example:
@@ -111,7 +110,6 @@ print-asm = { virtual = true, allocated = true, final = true }
 terse = false
 time-phases = false
 include-tests = false
-json-abi-with-callpaths = false
 error-on-warnings = false
 experimental-private-modules = false
 ```
diff --git a/docs/book/src/forc/plugins/forc_client/forc_deploy.md b/docs/book/src/forc/plugins/forc_client/forc_deploy.md
index 96a3b57a5a5..5fd00d93425 100644
--- a/docs/book/src/forc/plugins/forc_client/forc_deploy.md
+++ b/docs/book/src/forc/plugins/forc_client/forc_deploy.md
@@ -1 +1 @@
-# `forc deploy`
+# forc deploy
diff --git a/docs/book/src/forc/plugins/forc_client/forc_run.md b/docs/book/src/forc/plugins/forc_client/forc_run.md
index 008a92b9593..7d6f88c8db5 100644
--- a/docs/book/src/forc/plugins/forc_client/forc_run.md
+++ b/docs/book/src/forc/plugins/forc_client/forc_run.md
@@ -1 +1 @@
-# `forc run`
+# forc run
diff --git a/docs/book/src/forc/plugins/forc_client/forc_submit.md b/docs/book/src/forc/plugins/forc_client/forc_submit.md
index 54e1e5f6c5e..ad314de43e7 100644
--- a/docs/book/src/forc/plugins/forc_client/forc_submit.md
+++ b/docs/book/src/forc/plugins/forc_client/forc_submit.md
@@ -1 +1 @@
-# `forc submit`
+# forc submit
diff --git a/docs/book/src/forc/plugins/forc_client/index.md b/docs/book/src/forc/plugins/forc_client/index.md
index 9c044221f47..feb436af788 100644
--- a/docs/book/src/forc/plugins/forc_client/index.md
+++ b/docs/book/src/forc/plugins/forc_client/index.md
@@ -1,26 +1,64 @@
-# `forc-client`
+# forc-client
 
-Forc plugin for interacting with a Fuel node.
+The forc plugin for interacting with a Fuel node.
 
-## Initializing the wallet and adding accounts
+Since transactions are going to require some gas, you need to sign them with an account that has enough coins to pay for them.
 
-If you don't have an initialized wallet or any account for your wallet you won't be able to sign transactions.
+We offer multiple ways to sign the transaction:
 
-To create a wallet you can use `forc wallet new`. It will ask you to choose a password to encrypt your wallet. After the initialization is done you will have your mnemonic phrase.
+  1. Sign the transaction via your local wallet using `forc-client` which integrates with our CLI wallet, `forc-wallet`.
+  2. Use the default signer to deploy to a local node
+  3. Use `forc-wallet` to manually sign transactions, and copy the signed transaction back to `forc-client`.
 
-After you have created a wallet, you can derive a new account by running `forc wallet account new`. It will ask your password to decrypt the wallet before deriving an account.
+The easiest and recommended way to interact with deployed networks such as our testnets is option 1, using `forc-client` to sign your transactions which reads your default `forc-wallet` vault. For interacting with local node, we recommend using the second option, which leads `forc-client` to sign transactions with the private key that comes pre-funded in local environments.
 
-## Signing transactions using `forc-wallet` CLI
+## Option 1: Sign transactions via forc-client using your local forc-wallet vault
 
-To submit the transactions created by `forc deploy` or `forc run`, you need to sign them first (unless you are using a client without UTXO validation). To sign a transaction you can use `forc-wallet` CLI. This section is going to walk you through the whole signing process.
+If you've used `forc-wallet` before, you'll already have a secure, password-protected vault holding your private key written to your file-system. `forc-client` is compatible with `forc-wallet` such that it can read that vault by asking you your password and use your account to sign transactions.
 
-By default `fuel-core` runs without UTXO validation, this allows you to send invalid inputs to emulate different conditions.
+Example:
 
-If you want to run `fuel-core` with UTXO validation, you can pass `--utxo-validation` to `fuel-core run`.
+```console
+> forc deploy
 
-To install `forc-wallet` please refer to `forc-wallet`'s [GitHub repo](https://github.com/FuelLabs/forc-wallet#forc-wallet).
+    Building /Users/yourname/test-projects/test-contract
+    Finished release [optimized + fuel] target(s) in 11.39s
+  Confirming transactions [deploy impl-contract]
+             Network: https://testnet.fuel.network
+             Wallet: /Users/yourname/.fuel/wallets/.wallet
+✔ Wallet password · ********
+? Wallet account ›
+❯ [0] fuel12pls73y9hnqdqthvduy2x44x48zt8s50pkerf32kq26f2afeqdwq6rj9ar - 0.002197245 ETH
+  [1] fuel1vzrm6kw9s3tv85gl25lpptsxrdguyzfhq6c8rk07tr6ft5g45nwqqh0uty - 0.001963631 ETH
+? Do you agree to sign 1 transaction? (y/n) › yes
+     Finished deploying impl-contract https://app.fuel.network/contract/0x94b712901f04332682d14c998a5fc5a078ed15321438f46d58d0383200cde43d
+     Deployed in block https://app.fuel.network/block/5958351
+```
+
+As it can be seen from the example, `forc-client` asks for your password to decrypt the `forc-wallet` vault, and list your accounts so that you can select the one you want to fund the transaction with.
+
+## Option 2: Using default signer
+
+If you are not interacting with a deployed network, such as testnets, your local `fuel-core` environment can be structured such that it funds an account by default. Using `--default-signer` flag with `forc-client` binaries (run, deploy) will instruct `forc-client` to sign transactions with this pre-funded account. This makes it a useful command while working against a local node.
+
+Example:
+
+```console
+> forc deploy --default-signer
 
-1. Construct the transaction by using either `forc deploy` or `forc run`. To do so simply run `forc deploy` or `forc run` with your desired parameters. For a list of parameters please refer to the [forc-deploy](./forc_deploy.md) or [forc-run](./forc_run.md) section of the book. Once you run either command you will be asked the address of the wallet you are going to be signing with. After the address is given the transaction will be generated and you will be given a transaction ID. At this point CLI will actively wait for you to insert the signature.
+    Building /Users/test/test-projects/test-contract
+    Finished release [optimized + fuel] target(s) in 11.40s
+  Confirming transactions [deploy impl-contract]
+             Network: http://127.0.0.1:4000
+    Finished deploying impl-contract 0xf9fb08ef18ce226954270d6d4f67677d484b8782a5892b3d436572b405407544
+    Deployed in block 00000001
+```
+
+## Option 3: Manually signing through forc-wallet (Deprecated)
+
+This option is for creating the transaction first, signing it manually, and supplying the signed transaction back to forc-client. Since it requires multiple steps, it is more error-prone and not recommended for general use cases. Also this will be deprecated soon.
+
+1. Construct the transaction by using either `forc deploy` or `forc run`. To do so simply run `forc deploy --manual-sign` or `forc run --manual-sign` with your desired parameters. For a list of parameters please refer to the [forc-deploy](./forc_deploy.md) or [forc-run](./forc_run.md) section of the book. Once you run either command you will be asked the address of the wallet you are going to be signing with. After the address is given the transaction will be generated and you will be given a transaction ID. At this point CLI will actively wait for you to insert the signature.
 2. Take the transaction ID generated in the first step and sign it with `forc wallet sign --account <account_index> tx-id <transaction_id>`. This will generate a signature.
 3. Take the signature generated in the second step and provide it to `forc-deploy` (or `forc-run`). Once the signature is provided, the signed transaction will be submitted.
 
@@ -54,28 +92,44 @@ By default `--default-signer` flag would sign your transactions with the followi
 0xde97d8624a438121b86a1956544bd72ed68cd69f2c99555b08b1e8c51ffd511c
 ```
 
-## Interacting with the testnet
+## Selecting a target network
 
-To interact with the latest testnet, use the `--testnet` flag. When this flag is passed, transactions created by `forc-deploy` will be sent to the `beta-4` testnet.
+By default, `local` is used for the target network. To interact with the latest testnet, use the `--testnet` flag. When this flag is passed, transactions created by `forc-deploy` will be sent to the latest `testnet`:
 
 ```sh
 forc-deploy --testnet
 ```
 
-It is also possible to pass the exact node URL while using `forc-deploy` or `forc-run` which can be done using `--node-url` flag.
+The same can be done to target mainnet:
+
+```sh
+forc-deploy --mainnet
+```
+
+It is also possible to pass the exact node URL while using `forc-deploy` or `forc-run` which can be done using `--node-url` flag:
 
 ```sh
-forc-deploy --node-url https://beta-3.fuel.network
+forc-deploy --node-url https://mainnet.fuel.network
 ```
 
-Another alternative is the `--target` option, which provides useful aliases to all targets. For example if you want to deploy to `beta-3` you can use:
+Another alternative is the `--target` option, which provides useful aliases to all targets. For example if you want to deploy to `testnet` you can use:
 
 ```sh
-forc-deploy --target beta-3
+forc-deploy --target testnet
 ```
 
 Since deploying and running projects on the testnet cost gas, you will need coins to pay for them. You can get some using the [testnet faucet](https://faucet-testnet.fuel.network/).
 
+## Delayed transactions
+
+For delayed transactions, you can use the `--submit-only` flag. This flag allows you to submit the transaction without waiting for its finalization.
+
+One use case for this is multisig transactions, where a deployment transaction may stay in a pending state while waiting for all signatures.
+
+```sh
+forc-deploy --submit-only
+```
+
 ## Deployment Artifacts
 
 forc-deploy saves the details of each deployment in the `out/deployments` folder within the project's root directory. Below is an example of a deployment artifact:
@@ -91,3 +145,65 @@ forc-deploy saves the details of each deployment in the `out/deployments` folder
   "deployed_block_id": "0x915c6f372252be6bc54bd70df6362dae9bf750ba652bf5582d9b31c7023ca6cf"
 }
 ```
+
+## Proxy Contracts
+
+`forc-deploy` supports deploying proxy contracts automatically if it is enabled in the `Forc.toml` of the contract.
+
+```TOML
+[project]
+name = "test_contract"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[proxy]
+enabled = true
+```
+
+If there is no `address` field present under the proxy table, like the example above, `forc` will automatically create a proxy contract based on the [SRC-14](https://github.com/FuelLabs/sway-standards/blob/master/docs/src/src-14-simple-upgradeable-proxies.md) implementation from [sway-standards](https://github.com/FuelLabs/sway-standards). After generating and deploying the proxy contract, the target is set to the current contract, and the owner of the proxy is set to the account that is signing the transaction for deployment.
+
+This means that if you simply enable proxy in the `Forc.toml`, forc will automatically deploy a proxy contract for you and you do not need to do anything manually aside from signing the deployment transactions for the proxy contract. After deploying the proxy contract, the address is added into the `address` field of the proxy table.
+
+If you want to update the target of an [SRC-14](https://github.com/FuelLabs/sway-standards/blob/master/docs/src/src-14-simple-upgradeable-proxies.md) compliant proxy contract rather than deploying a new one, simply add its `address` in the `address` field, like the following example:
+
+```TOML
+[project]
+name = "test_contract"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[proxy]
+enabled = true
+address = "0xd8c4b07a0d1be57b228f4c18ba7bca0c8655eb6e9d695f14080f2cf4fc7cd946" # example proxy contract address
+```
+
+If an `address` is present, `forc` calls into that contract to update its `target` instead of deploying a new contract. Since a new proxy deployment adds its own `address` into the `Forc.toml` automatically, you can simply enable the proxy once and after the initial deployment, `forc` will keep updating the target accordingly for each new deployment of the same contract.
+
+## Large Contracts
+
+For contracts over the maximum contract size limit (currently `100kB`) defined by the network, `forc-deploy` will split the contract into chunks and deploy the contract with multiple transactions using the Rust SDK's [loader contract](https://github.com/FuelLabs/fuels-rs/blob/master/docs/src/deploying/large_contracts.md) functionality. Chunks that have already been deployed will be reused on subsequent deployments.
+
+## Deploying Scripts and Predicates
+
+`forc deploy` now supports deploying scripts and predicates in addition to contracts. These are deployed as blobs with generated loaders for efficiency.
+
+Scripts and predicates are deployed automatically when you run `forc deploy` on a project that contains them. The deployment process differs slightly from contract deployment:
+
+1. For scripts and predicates, the bytecode is uploaded as a blob.
+2. A loader is generated that can load and execute the blob.
+3. The loader bytecode is saved in the project's output directory.
+
+After deployment, you'll find new files in your project's output directory:
+
+- For scripts: `<script_name>-loader.bin`
+- For predicates: `<predicate_name>-loader.bin` and `<predicate_name>-loader-root`
+
+The loader files contain the bytecode necessary to load and execute your script or predicate from the deployed blob.
+
+This new deployment method allows for more efficient storage and execution of scripts and predicates on the Fuel network.
+
+Note: Contracts are still deployed directly, not as blobs given that the contract size is under the maximum contract size limit defined by network (currently `100kB`).
diff --git a/docs/book/src/forc/plugins/forc_crypto.md b/docs/book/src/forc/plugins/forc_crypto.md
index c0789970b64..7c5aa994161 100644
--- a/docs/book/src/forc/plugins/forc_crypto.md
+++ b/docs/book/src/forc/plugins/forc_crypto.md
@@ -1 +1 @@
-# `forc crypto`
+# forc crypto
diff --git a/docs/book/src/forc/plugins/forc_doc.md b/docs/book/src/forc/plugins/forc_doc.md
index e554a752e6d..2f664873b33 100644
--- a/docs/book/src/forc/plugins/forc_doc.md
+++ b/docs/book/src/forc/plugins/forc_doc.md
@@ -1 +1 @@
-# `forc doc`
+# forc doc
diff --git a/docs/book/src/forc/plugins/forc_explore.md b/docs/book/src/forc/plugins/forc_explore.md
index b86cb623cdf..c8d4ca5ed5b 100644
--- a/docs/book/src/forc/plugins/forc_explore.md
+++ b/docs/book/src/forc/plugins/forc_explore.md
@@ -1 +1 @@
-# `forc explore`
+# forc explore
diff --git a/docs/book/src/forc/plugins/forc_fmt.md b/docs/book/src/forc/plugins/forc_fmt.md
index 667a7c1b635..f49f6b7877b 100644
--- a/docs/book/src/forc/plugins/forc_fmt.md
+++ b/docs/book/src/forc/plugins/forc_fmt.md
@@ -1 +1 @@
-# `forc fmt`
+# forc fmt
diff --git a/docs/book/src/forc/plugins/forc_lsp.md b/docs/book/src/forc/plugins/forc_lsp.md
index b5a93f24f24..624d69001f7 100644
--- a/docs/book/src/forc/plugins/forc_lsp.md
+++ b/docs/book/src/forc/plugins/forc_lsp.md
@@ -1 +1 @@
-# `forc lsp`
+# forc lsp
diff --git a/docs/book/src/index.md b/docs/book/src/index.md
index 5873263e144..00b6fad6375 100644
--- a/docs/book/src/index.md
+++ b/docs/book/src/index.md
@@ -59,11 +59,11 @@ You can find example applications built with Sway in the [Sway Applications repo
 
 **Q: What is the standard library?**
 
-The [standard library](./introduction/standard_library.md), also referred to as `std`, is a library that offers core functions and helpers for developing in Sway. The standard library has it's own [reference documentation](https://fuellabs.github.io/sway/master/std/) that has detailed information about each module in `std`.
+The [standard library](./introduction/standard_library.md), also referred to as `std`, is a library that offers core functions and helpers for developing in Sway. The standard library has its own [reference documentation](https://fuellabs.github.io/sway/master/std/) that has detailed information about each module in `std`.
 
 **Q: What are Sway standards?**
 
-Similar to ERC standards for Ethereum and Solidity, Sway has it's own SRC standards that help enable cross compatibility across different smart contracts. For more information on using a Sway Standard, you can check out the [Sway-Standards Repository](https://github.com/FuelLabs/sway-standards).
+Similar to ERC standards for Ethereum and Solidity, Sway has its own SRC standards that help enable cross compatibility across different smart contracts. For more information on using a Sway Standard, you can check out the [Sway-Standards Repository](https://github.com/FuelLabs/sway-standards).
 
 **Q: How can I make a token?**
 
diff --git a/docs/book/src/introduction/core_library.md b/docs/book/src/introduction/core_library.md
new file mode 100644
index 00000000000..314db3e5c02
--- /dev/null
+++ b/docs/book/src/introduction/core_library.md
@@ -0,0 +1,30 @@
+# Core Library
+
+The Sway Core Library, like the name suggests contains core operators and logic for the primitive types of the Sway programming language. These traits and methods are an extension of the [primitive types](https://docs.fuel.network/docs/sway/basics/built_in_types/#primitive-types) `u8`, `u16`, `u32`, `u64`, `u256`, `str[]`, `str`, `bool` and , `b256` and can be used where appropriate.
+
+The latest core library documentation can be found [here](https://fuellabs.github.io/sway/master/core/). If the latest version is not compatible please refer to the appropriate tagged release.
+
+## Using the Core Library
+
+Core library functionalities do not need to be explicitly imported and will work out of the box after creating any new Sway project with [`forc new`](../forc/commands/forc_new.md). The `use` keyword is simply not required.
+
+Consider this example of using the modulo function for two like value types:
+
+```sway
+let val_1 = 10;
+let val_2 = 2;
+let result = val_1 % val_2;
+```
+
+## Core Library Prelude
+
+The prelude contains a list of operations essential to all Sway programs. The latest version of the prelude can be found [here](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/prelude.sw).
+
+- [`core::primitives::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/primitives.sw)
+- [`core::primitive_conversions::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/primitive_conversions.sw)
+- [`core::raw_ptr::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/raw_ptr.sw)
+- [`core::raw_slice::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/raw_slice.sw)
+- [`core::ops::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/ops.sw)
+- [`core::storage::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/storage.sw)
+- [`core::str::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/str.sw)
+- [`core::codec::*`](https://github.com/FuelLabs/sway/blob/master/sway-lib-core/src/codec.sw)
diff --git a/docs/book/src/introduction/index.md b/docs/book/src/introduction/index.md
index 8328fdaf1ba..33694f3f541 100644
--- a/docs/book/src/introduction/index.md
+++ b/docs/book/src/introduction/index.md
@@ -6,4 +6,5 @@ To get started with Forc and Sway smart contract development, install the Fuel t
 - [The Fuel Toolchain](./fuel_toolchain.md)
 - [A Forc Project](./forc_project.md)
 - [Standard Library](./standard_library.md)
+- [Core Library](./core_library.md)
 - [Sway Language Standards](./sway_standards.md)
diff --git a/docs/book/src/lsp/features.md b/docs/book/src/lsp/features.md
index c5791915956..56a8c8acb31 100644
--- a/docs/book/src/lsp/features.md
+++ b/docs/book/src/lsp/features.md
@@ -12,17 +12,13 @@ _Source:_ [completion.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/
 
 Suggests code to follow partially written statements for functions and variables.
 
-## Diagnostics
-
-_Source:_ [diagnostic.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/src/capabilities/diagnostic.rs)
-
-Displays compiler warnings and errors inline.
+## Go to Definition
 
-## Syntax Highlighting
+Jumps to the definition of a symbol from its usage.
 
-_Source:_ [highlight.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/src/capabilities/highlight.rs)
+## Find All References
 
-Highlights code based on type and context.
+Locates all occurrences of a symbol throughout the project.
 
 ## Hover
 
@@ -42,6 +38,18 @@ _Source:_ [rename.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/src/
 
 Renames a symbol everywhere in the workspace.
 
+## Diagnostics
+
+_Source:_ [diagnostic.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/src/capabilities/diagnostic.rs)
+
+Displays compiler warnings and errors inline.
+
+## Syntax Highlighting
+
+_Source:_ [highlight.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/src/capabilities/highlight.rs)
+
+Highlights code based on type and context.
+
 ## Run
 
 _Source:_ [runnable.rs](https://github.com/FuelLabs/sway/blob/master/sway-lsp/src/capabilities/runnable.rs)
diff --git a/docs/book/src/lsp/troubleshooting.md b/docs/book/src/lsp/troubleshooting.md
index 2f17bf8c028..954e1a668e3 100644
--- a/docs/book/src/lsp/troubleshooting.md
+++ b/docs/book/src/lsp/troubleshooting.md
@@ -34,7 +34,7 @@ In the meantime, if it's too slow, you can disable the LSP server entirely with
 
 ## Server Logs
 
-You can you enable verbose logging of the LSP server.
+You can enable verbose logging of the LSP server.
 
 In VSCode, this is under the setting:
 
diff --git a/docs/book/src/reference/compiler_intrinsics.md b/docs/book/src/reference/compiler_intrinsics.md
index a0dfd0f7c62..c3ba29ce0e0 100644
--- a/docs/book/src/reference/compiler_intrinsics.md
+++ b/docs/book/src/reference/compiler_intrinsics.md
@@ -2,7 +2,7 @@
 
 The Sway compiler supports a list of intrinsics that perform various low level operations that are useful for building libraries. Compiler intrinsics should rarely be used but are preferred over `asm` blocks because they are type-checked and are safer overall. Below is a list of all available compiler intrinsics:
 
-___
+---
 
 ```sway
 __size_of_val<T>(val: T) -> u64
@@ -12,7 +12,7 @@ __size_of_val<T>(val: T) -> u64
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __size_of<T>() -> u64
@@ -22,7 +22,7 @@ __size_of<T>() -> u64
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __size_of_str_array<T>() -> u64
@@ -32,7 +32,7 @@ __size_of_str_array<T>() -> u64
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __assert_is_str_array<T>()
@@ -42,7 +42,7 @@ __assert_is_str_array<T>()
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __to_str_array(s: str) -> str[N]
@@ -52,7 +52,7 @@ __to_str_array(s: str) -> str[N]
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __is_reference_type<T>() -> bool
@@ -62,7 +62,7 @@ __is_reference_type<T>() -> bool
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __is_str_array<T>() -> bool
@@ -72,7 +72,7 @@ __is_str_array<T>() -> bool
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __eq<T>(lhs: T, rhs: T) -> bool
@@ -82,7 +82,7 @@ __eq<T>(lhs: T, rhs: T) -> bool
 
 **Constraints:** `T` is `bool`, `u8`, `u16`, `u32`, `u64`, `u256`, `b256` or `raw_ptr`.
 
-___
+---
 
 ```sway
 __gt<T>(lhs: T, rhs: T) -> bool
@@ -91,7 +91,8 @@ __gt<T>(lhs: T, rhs: T) -> bool
 **Description:** Returns whether `lhs` is greater than `rhs`.
 
 **Constraints:** `T` is `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
-___
+
+---
 
 ```sway
 __lt<T>(lhs: T, rhs: T) -> bool
@@ -100,7 +101,8 @@ __lt<T>(lhs: T, rhs: T) -> bool
 **Description:** Returns whether `lhs` is less than `rhs`.
 
 **Constraints:** `T` is `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
-___
+
+---
 
 ```sway
 __gtf<T>(index: u64, tx_field_id: u64) -> T
@@ -110,7 +112,7 @@ __gtf<T>(index: u64, tx_field_id: u64) -> T
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __addr_of<T>(val: T) -> raw_ptr
@@ -120,7 +122,7 @@ __addr_of<T>(val: T) -> raw_ptr
 
 **Constraints:** `T` is a reference type.
 
-___
+---
 
 ```sway
 __state_load_word(key: b256) -> u64
@@ -130,7 +132,7 @@ __state_load_word(key: b256) -> u64
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __state_load_quad(key: b256, ptr: raw_ptr, slots: u64) -> bool
@@ -140,7 +142,7 @@ __state_load_quad(key: b256, ptr: raw_ptr, slots: u64) -> bool
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __state_store_word(key: b256, val: u64) -> bool
@@ -150,7 +152,7 @@ __state_store_word(key: b256, val: u64) -> bool
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __state_store_quad(key: b256, ptr: raw_ptr, slots: u64) -> bool
@@ -160,7 +162,7 @@ __state_store_quad(key: b256, ptr: raw_ptr, slots: u64) -> bool
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __log<T>(val: T)
@@ -170,7 +172,7 @@ __log<T>(val: T)
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __add<T>(lhs: T, rhs: T) -> T
@@ -180,7 +182,7 @@ __add<T>(lhs: T, rhs: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`.
 
-___
+---
 
 ```sway
 __sub<T>(lhs: T, rhs: T) -> T
@@ -190,7 +192,7 @@ __sub<T>(lhs: T, rhs: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`.
 
-___
+---
 
 ```sway
 __mul<T>(lhs: T, rhs: T) -> T
@@ -200,7 +202,7 @@ __mul<T>(lhs: T, rhs: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`.
 
-___
+---
 
 ```sway
 __div<T>(lhs: T, rhs: T) -> T
@@ -210,7 +212,7 @@ __div<T>(lhs: T, rhs: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`.
 
-___
+---
 
 ```sway
 __and<T>(lhs: T, rhs: T) -> T
@@ -220,7 +222,7 @@ __and<T>(lhs: T, rhs: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
 
-___
+---
 
 ```sway
 __or<T>(lhs: T, rhs: T) -> T
@@ -230,7 +232,7 @@ __or<T>(lhs: T, rhs: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
 
-___
+---
 
 ```sway
 __xor<T>(lhs: T, rhs: T) -> T
@@ -239,7 +241,8 @@ __xor<T>(lhs: T, rhs: T) -> T
 **Description:** Bitwise XOR `lhs` and `rhs`.
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
-___
+
+---
 
 ```sway
 __mod<T>(lhs: T, rhs: T) -> T
@@ -248,7 +251,8 @@ __mod<T>(lhs: T, rhs: T) -> T
 **Description:** Modulo of `lhs` by `rhs`.
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`.
-___
+
+---
 
 ```sway
 __rsh<T>(lhs: T, rhs: u64) -> T
@@ -257,7 +261,8 @@ __rsh<T>(lhs: T, rhs: u64) -> T
 **Description:** Logical right shift of `lhs` by `rhs`.
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
-___
+
+---
 
 ```sway
 __lsh<T>(lhs: T, rhs: u64) -> T
@@ -266,7 +271,8 @@ __lsh<T>(lhs: T, rhs: u64) -> T
 **Description:** Logical left shift of `lhs` by `rhs`.
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
-___
+
+---
 
 ```sway
 __revert(code: u64)
@@ -276,7 +282,7 @@ __revert(code: u64)
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __ptr_add(ptr: raw_ptr, offset: u64)
@@ -286,7 +292,7 @@ __ptr_add(ptr: raw_ptr, offset: u64)
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __ptr_sub(ptr: raw_ptr, offset: u64)
@@ -296,7 +302,7 @@ __ptr_sub(ptr: raw_ptr, offset: u64)
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __smo<T>(recipient: b256, data: T, coins: u64)
@@ -306,7 +312,7 @@ __smo<T>(recipient: b256, data: T, coins: u64)
 
 **Constraints:** None.
 
-___
+---
 
 ```sway
 __not(op: T) -> T
@@ -316,7 +322,7 @@ __not(op: T) -> T
 
 **Constraints:** `T` is an integer type, i.e. `u8`, `u16`, `u32`, `u64`, `u256`, `b256`.
 
-___
+---
 
 ```sway
 __jmp_mem()
@@ -325,3 +331,44 @@ __jmp_mem()
 **Description:** Jumps to `MEM[$hp]`.
 
 **Constraints:** None.
+
+---
+
+```sway
+__slice(item: &[T; N], start: u64, end: u64) -> &[T]
+__slice(item: &[T], start: u64, end: u64) -> &[T]
+__slice(item: &mut [T; N], start: u64, end: u64) -> &mut [T]
+__slice(item: &mut [T], start: u64, end: u64) -> &mut [T]
+```
+
+**Description:** Slices an array or another slice.
+
+This intrinsic returns a reference to a slice containing the range of elements inside `item`.
+The mutability of reference is defined by the first parameter mutability.
+
+Runtime bound checks are not generated, and must be done manually when and where appropriated. Compile time bound checks are done when possible.
+
+**Constraints:**
+
+- `item` is an array or a slice;
+- when `start` is a literal, it must be smaller than `item` length;
+- when `end` is a literal, it must be smaller than or equal to `item` length;
+- `end` must be greater than or equal to `start`
+
+---
+
+```sway
+__elem_at(item: &[T; N], index: u64) -> &T
+__elem_at(item: &[T], index: u64) -> &T
+__elem_at(item: &mut [T; N], index: u64) -> &mut T
+__elem_at(item: &mut [T], index: u64) -> &mut T
+```
+
+**Description:** Returns a reference to the indexed element. The mutability of reference is defined by the first parameter mutability.
+
+Runtime bound checks are not generated, and must be done manually when and where appropriated. Compile time bound checks are done when possible.
+
+**Constraints:**
+
+- `item` is a reference to an array or a reference to a slice;
+- when `index` is a literal, it must be smaller than `item` length;
diff --git a/docs/book/src/reference/known_issues_and_workarounds.md b/docs/book/src/reference/known_issues_and_workarounds.md
index 50ae1052b67..d60c5d23de3 100644
--- a/docs/book/src/reference/known_issues_and_workarounds.md
+++ b/docs/book/src/reference/known_issues_and_workarounds.md
@@ -6,7 +6,7 @@
 
 ## Missing Features
 
-* [#1182](https://github.com/FuelLabs/sway/issues/1182) Arrays in a `storage` block are not yet supported. See the [Manual Storage Management](../blockchain-development/storage.md#manual-storage-management) section for details on how to use `store` and `get` from the standard library to manage storage slots directly. Note, however, that `StorageMap<K, V>` _does_ support arbitrary types for `K` and `V` without any limitations.
+* [#1182](https://github.com/FuelLabs/sway/issues/1182) Arrays in a `storage` block are not yet supported. See the [Manual Storage Management](../advanced/advanced_storage.md#manual-storage-management) section for details on how to use `store` and `get` from the standard library to manage storage slots directly. Note, however, that `StorageMap<K, V>` _does_ support arbitrary types for `K` and `V` without any limitations.
 
 ## General
 
diff --git a/docs/book/src/reference/undefined_behavior.md b/docs/book/src/reference/undefined_behavior.md
new file mode 100644
index 00000000000..07555223aad
--- /dev/null
+++ b/docs/book/src/reference/undefined_behavior.md
@@ -0,0 +1,15 @@
+# Behavior Considered Undefined
+
+Sway code that contains any of the following behavior is considered undefined.
+The compiler is allowed to treat undefined Sway code however it desires,
+including removing it or replacing it with any other Sway code.
+
+This is not an exhaustive list, it may grow or shrink, there is no formal model
+of Sway's semantics so there may be more behavior considered undefined. We
+reserve the right to make some of the listed behavior defined in the future.
+
+* Invalid arithmetic operations (overflows, underflows, division by zero, etc)
+* Misuse of compiler intrinsics
+* Incorrect use of inline assembly
+* Reading and writing `raw_ptr` and `raw_slice`
+* Slicing and indexing out of bounds by directly using compiler intrinsics.
diff --git a/docs/book/src/sway-program-types/index.md b/docs/book/src/sway-program-types/index.md
index fdd076181da..4efe5b47057 100644
--- a/docs/book/src/sway-program-types/index.md
+++ b/docs/book/src/sway-program-types/index.md
@@ -9,7 +9,7 @@ Every Sway file _must_ begin with a declaration of what type of program it is. A
 
 Contracts are used primarily for protocols or systems that operate within a fixed set of rules. A good example would be a staking contract or a decentralized exchange (also called a DEX).
 
-Scripts are used for complex on-chain interactions that won't persist. An example of this may be using a DEX and Lender to create a leveraged position (borrow, swap, re-collateralize, borrow) which is a complex transaction that would usually take multiple steps.
+Scripts are used for complex on-chain interactions that won't persist. An example of this may be using a DEX and Lender to create a leveraged position (borrow, swap, re-collateralize) which is a complex transaction that would usually take multiple steps.
 
 Libraries are for code that is reusable and useful for handling common situations. A good example of this would be a library to handle fixed-point math or big number math.
 
diff --git a/docs/book/src/testing/testing-with-rust.md b/docs/book/src/testing/testing-with-rust.md
index ce6fddf52c7..d87402f9c7d 100644
--- a/docs/book/src/testing/testing-with-rust.md
+++ b/docs/book/src/testing/testing-with-rust.md
@@ -74,18 +74,21 @@ Let's have a look at the result:
 $ tree .
 ├── Cargo.toml
 ├── Forc.toml
+├── build.rs
 ├── src
 │   └── main.sw
 └── tests
     └── harness.rs
 ```
 
-We have two new files!
+We have three new files!
 
 - The `Cargo.toml` is the manifest for our new test harness and specifies the
   required dependencies including `fuels` the Fuel Rust SDK.
 - The `tests/harness.rs` contains some boilerplate test code to get us started,
   though doesn't call any contract methods just yet.
+- The `build.rs` is a build script that compiles the Sway project with `forc build`
+  whenever `cargo test` is run.
 
 ### 4. Build the forc project
 
@@ -111,6 +114,7 @@ $ tree
 ├── Cargo.toml
 ├── Forc.lock
 ├── Forc.toml
+├── build.rs
 ├── out
 │   └── debug
 │       ├── my-fuel-project-abi.json
@@ -176,10 +180,13 @@ following:
 ```rust,ignore
 use fuels::{prelude::*, types::ContractId};
 
-// Load ABI from JSON
-abigen!(TestContract, "out/debug/my-fuel-project-abi.json");
+// Load abi from json
+abigen!(Contract(
+    name = "MyContract",
+    abi = "out/debug/my-fuel-project-abi.json"
+));
 
-async fn get_contract_instance() -> (TestContract, ContractId) {
+async fn get_contract_instance() -> (MyContract<WalletUnlocked>, ContractId) {
     // Launch a local network and deploy the contract
     let mut wallets = launch_custom_provider_and_get_wallets(
         WalletsConfig::new(
@@ -188,8 +195,10 @@ async fn get_contract_instance() -> (TestContract, ContractId) {
             Some(1_000_000_000), /* Amount per coin */
         ),
         None,
+        None,
     )
-    .await;
+    .await
+    .unwrap();
     let wallet = wallets.pop().unwrap();
 
     let id = Contract::load_from(
@@ -202,11 +211,11 @@ async fn get_contract_instance() -> (TestContract, ContractId) {
         ),
     )
     .unwrap()
-    .deploy(&wallet, TxParameters::default())
+    .deploy(&wallet, TxPolicies::default())
     .await
     .unwrap();
 
-    let instance = TestContract::new(id.to_string(), wallet);
+    let instance = MyContract::new(id.clone(), wallet);
 
     (instance, id.into())
 }
diff --git a/forc-plugins/forc-client/test/data/standalone_contract_b/.gitignore b/docs/reference/src/code/language/built-ins/slices/.gitignore
similarity index 100%
rename from forc-plugins/forc-client/test/data/standalone_contract_b/.gitignore
rename to docs/reference/src/code/language/built-ins/slices/.gitignore
diff --git a/docs/reference/src/code/language/built-ins/slices/Forc.lock b/docs/reference/src/code/language/built-ins/slices/Forc.lock
new file mode 100644
index 00000000000..d064967bf3b
--- /dev/null
+++ b/docs/reference/src/code/language/built-ins/slices/Forc.lock
@@ -0,0 +1,14 @@
+[[package]]
+name = 'arrays'
+source = 'root'
+dependencies = ['std']
+
+[[package]]
+name = 'core'
+source = 'path+from-root-54F92B42A645EA2B'
+dependencies = []
+
+[[package]]
+name = 'std'
+source = 'git+https://github.com/fuellabs/sway?tag=v0.24.5#e695606d8884a18664f6231681333a784e623bc9'
+dependencies = ['core']
diff --git a/docs/reference/src/code/language/built-ins/slices/Forc.toml b/docs/reference/src/code/language/built-ins/slices/Forc.toml
new file mode 100644
index 00000000000..d62b0a85072
--- /dev/null
+++ b/docs/reference/src/code/language/built-ins/slices/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "slices"
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/docs/reference/src/code/language/built-ins/slices/src/lib.sw b/docs/reference/src/code/language/built-ins/slices/src/lib.sw
new file mode 100644
index 00000000000..5319cec8dac
--- /dev/null
+++ b/docs/reference/src/code/language/built-ins/slices/src/lib.sw
@@ -0,0 +1,7 @@
+library;
+
+// ANCHOR: syntax
+fn syntax(s: &[u64]) -> u64 {
+    s.len()
+}
+// ANCHOR_END: syntax
diff --git a/docs/reference/src/documentation/introduction/installation/cargo.md b/docs/reference/src/documentation/introduction/installation/cargo.md
index 2bb6adc28c9..f4a4cd68267 100644
--- a/docs/reference/src/documentation/introduction/installation/cargo.md
+++ b/docs/reference/src/documentation/introduction/installation/cargo.md
@@ -1,7 +1,7 @@
 # Cargo
 
 <!-- markdown-link-check-disable -->
-Cargo can be used to install the Sway toolchain with various [`plugins`](https://fuellabs.github.io/sway/v0.60.0/book/forc/plugins/index.html).
+Cargo can be used to install the Sway toolchain with various [`plugins`](https://fuellabs.github.io/sway/v0.61.1/book/forc/plugins/index.html).
 <!-- markdown-link-check-enable -->
 
 ## Dependencies
diff --git a/docs/reference/src/documentation/introduction/installation/index.md b/docs/reference/src/documentation/introduction/installation/index.md
index 010ec129353..2dddb76e902 100644
--- a/docs/reference/src/documentation/introduction/installation/index.md
+++ b/docs/reference/src/documentation/introduction/installation/index.md
@@ -19,9 +19,9 @@ The supported operating systems include Linux and macOS; however, Windows is [`u
 `Cargo` may be used instead of [`Fuelup`](fuelup.md); however, the user needs to manage the toolchain themselves.
 
 <!-- markdown-link-check-disable -->
-The advantage of using `Cargo` is the installation of [`plugins`](https://fuellabs.github.io/sway/v0.60.0/book/forc/plugins/index.html) that have not been added into [`Fuelup`](fuelup.md).
+The advantage of using `Cargo` is the installation of [`plugins`](https://fuellabs.github.io/sway/v0.61.1/book/forc/plugins/index.html) that have not been added into [`Fuelup`](fuelup.md).
 
-The disadvantage occurs when [`Fuelup`](fuelup.md) and `Cargo` are used in tandem because the latest [`plugins`](https://fuellabs.github.io/sway/v0.60.0/book/forc/plugins/index.html) may not be recognized.
+The disadvantage occurs when [`Fuelup`](fuelup.md) and `Cargo` are used in tandem because the latest [`plugins`](https://fuellabs.github.io/sway/v0.61.1/book/forc/plugins/index.html) may not be recognized.
 <!-- markdown-link-check-enable -->
 
 ## Source
diff --git a/docs/reference/src/documentation/introduction/installation/source.md b/docs/reference/src/documentation/introduction/installation/source.md
index 1826684e933..283c4e19de6 100644
--- a/docs/reference/src/documentation/introduction/installation/source.md
+++ b/docs/reference/src/documentation/introduction/installation/source.md
@@ -5,7 +5,7 @@ The `Sway toolchain` can be built directly from the [`Sway repository`](https://
 ## Installation & Updating
 
 <!-- markdown-link-check-disable -->
-In the root of the repository `/sway/<here>` build [`forc`](https://fuellabs.github.io/sway/v0.60.0/book/forc/commands/index.html) with the following command:
+In the root of the repository `/sway/<here>` build [`forc`](https://fuellabs.github.io/sway/v0.61.1/book/forc/commands/index.html) with the following command:
 <!-- markdown-link-check-enable -->
 
 ```bash
diff --git a/docs/reference/src/documentation/language/built-ins/index.md b/docs/reference/src/documentation/language/built-ins/index.md
index a3ec2dcf7e0..be937b242b4 100644
--- a/docs/reference/src/documentation/language/built-ins/index.md
+++ b/docs/reference/src/documentation/language/built-ins/index.md
@@ -22,8 +22,10 @@ Sway has the following primitive types:
    1. `str[n]` (fixed-length string of size n)
 4. [Bytes](b256.md)
    1. `b256` (256 bits / 32 bytes, i.e. a hash)
+5. [Slices](slices.md)
 
 <!-- TODO: The following sentence does not belong here. We need to convey the default size, including word size, somewhere however not on this page -->
+
 The default numeric type is `u64`. The FuelVM's word size is 64 bits, and the cases where using a smaller numeric type to save space are minimal.
 
 All other types in Sway are built up of these primitive types, or references to these primitive types.
diff --git a/docs/reference/src/documentation/language/built-ins/slices.md b/docs/reference/src/documentation/language/built-ins/slices.md
new file mode 100644
index 00000000000..777a7cb1b8a
--- /dev/null
+++ b/docs/reference/src/documentation/language/built-ins/slices.md
@@ -0,0 +1,14 @@
+# Slices
+
+A slice is similar to an [array](arrays.md), in the sense that it is a contiguous sequence of elements of the same type.
+
+Unlike arrays, slices cannot be allocated, because its size is unknown at compilation time. The only way to use slices is through references to a slice.
+
+References to slice are "fat pointers" containing two items:
+
+- a pointer to the first element of the slice;
+- a `u64` with how many elements the slice has.
+
+```sway
+{{#include ../../../code/language/built-ins/slices/src/lib.sw:syntax}}
+```
diff --git a/docs/reference/src/documentation/language/program-types/index.md b/docs/reference/src/documentation/language/program-types/index.md
index 30b14667164..1e0154b93ae 100644
--- a/docs/reference/src/documentation/language/program-types/index.md
+++ b/docs/reference/src/documentation/language/program-types/index.md
@@ -9,7 +9,7 @@ A Sway program can be one of four types:
 - [library](libraries/index.md)
   - Reusable code for handling common operations
 - [script](script.md)
-  - Used for complex, multi-step, on-chain interactions that won't persist, such as using a decentralized exchange to create a leveraged position (borrow, swap, re-collateralize, borrow)
+  - Used for complex, multi-step, on-chain interactions that won't persist, such as using a decentralized exchange to create a leveraged position (borrow, swap, re-collateralize)
 - [predicate](predicate.md)
   - A set of preconditions to the construction of a transaction, the result of which must be a Boolean value of `true` in order for the transaction to be considered valid
 
diff --git a/docs/reference/src/index.md b/docs/reference/src/index.md
index 9a9ec8fedb0..400aef9503b 100644
--- a/docs/reference/src/index.md
+++ b/docs/reference/src/index.md
@@ -1,5 +1,5 @@
 # The Sway Reference
 
 <!-- markdown-link-check-disable -->
-This is the technical reference for the Sway programming language. For a prose explanation and introduction to the language, please refer to the [Sway Book](https://fuellabs.github.io/sway/v0.60.0/book/).
+This is the technical reference for the Sway programming language. For a prose explanation and introduction to the language, please refer to the [Sway Book](https://fuellabs.github.io/sway/v0.61.1/book/).
 <!-- markdown-link-check-enable -->
diff --git a/examples/advanced_storage_variables/src/main.sw b/examples/advanced_storage_variables/src/main.sw
index ac955c6e45c..75054ab7149 100644
--- a/examples/advanced_storage_variables/src/main.sw
+++ b/examples/advanced_storage_variables/src/main.sw
@@ -14,9 +14,9 @@ use std::storage::storage_vec::*;
 use std::storage::storage_bytes::*;
 // ANCHOR: storage_bytes_import
 
-// ANCHOR: storage_bytes_import
+// ANCHOR: storage_string_import
 use std::storage::storage_string::*;
-// ANCHOR: storage_bytes_import
+// ANCHOR: storage_string_import
 
 // ANCHOR: advanced_storage_declaration
 storage {
diff --git a/examples/storage_namespace/src/main.sw b/examples/storage_namespace/src/main.sw
index 40ddb1632a8..7adad8f5cbe 100644
--- a/examples/storage_namespace/src/main.sw
+++ b/examples/storage_namespace/src/main.sw
@@ -3,10 +3,11 @@ contract;
 use std::storage::storage_api::{read, write};
 
 // ANCHOR: storage_namespace
-#[namespace(example_namespace)]
 storage {
+    example_namespace {
+        foo: u64 = 0,
+    },
     // ANCHOR_END: storage_namespace
-    foo: u64 = 0,
 }
 
 abi StorageNamespaceExample {
diff --git a/forc-pkg/Cargo.toml b/forc-pkg/Cargo.toml
index dae1aab96fc..7c5618d4a4e 100644
--- a/forc-pkg/Cargo.toml
+++ b/forc-pkg/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-pkg"
-version = "0.60.0"
+version.workspace = true
 description = "Building, locking, fetching and updating Sway projects as Forc packages."
 authors.workspace = true
 edition.workspace = true
@@ -9,40 +9,41 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-ansi_term = "0.12"
-anyhow = "1"
-cid = "0.10"
-forc-tracing = { version = "0.60.0", path = "../forc-tracing" }
-forc-util = { version = "0.60.0", path = "../forc-util" }
-fuel-abi-types = { workspace = true }
-futures = "0.3"
-git2 = { version = "0.17.2", features = [
+ansi_term.workspace = true
+anyhow.workspace = true
+byte-unit.workspace = true
+cid.workspace = true
+forc-tracing.workspace = true
+forc-util.workspace = true
+fuel-abi-types.workspace = true
+futures.workspace = true
+git2 = { workspace = true, features = [
     "vendored-libgit2",
     "vendored-openssl",
 ] }
-gix-url = { version = "0.16.0", features = ["serde1"] }
-hex = "0.4.3"
-ipfs-api-backend-hyper = { version = "0.6", features = ["with-builder"] }
-petgraph = { version = "0.6", features = ["serde-1"] }
-reqwest = "0.11.7"
-semver = { version = "1.0", features = ["serde"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_ignored = "0.1.9"
-serde_json = "1.0"
-serde_with = "3.3.0"
-sway-core = { version = "0.60.0", path = "../sway-core" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-tar = "0.4.38"
-toml = { version = "0.7", features = ["parse"] }
-tracing = "0.1"
-url = { version = "2.2", features = ["serde"] }
-vec1 = "1.8.0"
-walkdir = "2"
+gix-url = { workspace = true, features = ["serde"] }
+hex.workspace = true
+ipfs-api-backend-hyper = { workspace = true, features = ["with-builder"] }
+petgraph = { workspace = true, features = ["serde-1"] }
+reqwest.workspace = true
+semver = { workspace = true, features = ["serde"] }
+serde = { workspace = true, features = ["derive"] }
+serde_ignored.workspace = true
+serde_json.workspace = true
+serde_with.workspace = true
+sway-core.workspace = true
+sway-error.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+tar.workspace = true
+toml = { workspace = true, features = ["parse"] }
+tracing.workspace = true
+url = { workspace = true, features = ["serde"] }
+vec1.workspace = true
+walkdir.workspace = true
 
 [dev-dependencies]
 regex = "^1.10.2"
 
 [target.'cfg(not(target_os = "macos"))'.dependencies]
-sysinfo = "0.29.0"
+sysinfo = "0.29"
diff --git a/forc-pkg/src/lock.rs b/forc-pkg/src/lock.rs
index b44504cf2b7..594c107bc09 100644
--- a/forc-pkg/src/lock.rs
+++ b/forc-pkg/src/lock.rs
@@ -1,5 +1,6 @@
 use crate::{pkg, source, DepKind, Edge};
 use anyhow::{anyhow, Result};
+use forc_tracing::{println_action_green, println_action_red};
 use petgraph::{visit::EdgeRef, Direction};
 use serde::{Deserialize, Serialize};
 use std::{
@@ -351,10 +352,9 @@ where
                 true => format!(" {}", pkg.source),
                 false => String::new(),
             };
-            tracing::info!(
-                "  {} {}{src}",
-                ansi_term::Colour::Red.bold().paint("Removing"),
-                ansi_term::Style::new().bold().paint(&pkg.name)
+            println_action_red(
+                "Removing",
+                &format!("{}{src}", ansi_term::Style::new().bold().paint(&pkg.name)),
             );
         }
     }
@@ -370,10 +370,9 @@ where
                 true => format!(" {}", pkg.source),
                 false => "".to_string(),
             };
-            tracing::info!(
-                "    {} {}{src}",
-                ansi_term::Colour::Green.bold().paint("Adding"),
-                ansi_term::Style::new().bold().paint(&pkg.name)
+            println_action_green(
+                "Adding",
+                &format!("{}{src}", ansi_term::Style::new().bold().paint(&pkg.name)),
             );
         }
     }
diff --git a/forc-pkg/src/manifest/build_profile.rs b/forc-pkg/src/manifest/build_profile.rs
index 0922ba59124..59610ee8bf9 100644
--- a/forc-pkg/src/manifest/build_profile.rs
+++ b/forc-pkg/src/manifest/build_profile.rs
@@ -24,6 +24,8 @@ pub struct BuildProfile {
     #[serde(default)]
     pub print_bytecode: bool,
     #[serde(default)]
+    pub print_bytecode_spans: bool,
+    #[serde(default)]
     pub terse: bool,
     #[serde(default)]
     pub time_phases: bool,
@@ -32,8 +34,6 @@ pub struct BuildProfile {
     #[serde(default)]
     pub include_tests: bool,
     #[serde(default)]
-    pub json_abi_with_callpaths: bool,
-    #[serde(default)]
     pub error_on_warnings: bool,
     #[serde(default)]
     pub reverse_results: bool,
@@ -57,11 +57,11 @@ impl BuildProfile {
             print_ir: PrintIr::default(),
             print_asm: PrintAsm::default(),
             print_bytecode: false,
+            print_bytecode_spans: false,
             terse: false,
             time_phases: false,
             metrics_outfile: None,
             include_tests: false,
-            json_abi_with_callpaths: false,
             error_on_warnings: false,
             reverse_results: false,
             optimization_level: OptLevel::Opt0,
@@ -80,11 +80,11 @@ impl BuildProfile {
             print_ir: PrintIr::default(),
             print_asm: PrintAsm::default(),
             print_bytecode: false,
+            print_bytecode_spans: false,
             terse: false,
             time_phases: false,
             metrics_outfile: None,
             include_tests: false,
-            json_abi_with_callpaths: false,
             error_on_warnings: false,
             reverse_results: false,
             optimization_level: OptLevel::Opt1,
@@ -152,11 +152,11 @@ mod tests {
             print_ir: PrintIr::r#final(),
             print_asm: PrintAsm::all(),
             print_bytecode: true,
+            print_bytecode_spans: false,
             terse: true,
             time_phases: true,
             metrics_outfile: Some("metrics_outfile".into()),
             include_tests: true,
-            json_abi_with_callpaths: true,
             error_on_warnings: true,
             reverse_results: true,
             optimization_level: OptLevel::Opt0,
diff --git a/forc-pkg/src/manifest/mod.rs b/forc-pkg/src/manifest/mod.rs
index 3f7bc21b1bd..28729aff757 100644
--- a/forc-pkg/src/manifest/mod.rs
+++ b/forc-pkg/src/manifest/mod.rs
@@ -186,6 +186,7 @@ pub struct PackageManifest {
     pub build_target: Option<BTreeMap<String, BuildTarget>>,
     build_profile: Option<BTreeMap<String, BuildProfile>>,
     pub contract_dependencies: Option<BTreeMap<String, ContractDependency>>,
+    pub proxy: Option<Proxy>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -273,6 +274,17 @@ pub struct DependencyDetails {
     pub(crate) ipfs: Option<String>,
 }
 
+/// Describes the details around proxy contract.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct Proxy {
+    pub enabled: bool,
+    /// Points to the proxy contract to be updated with the new contract id.
+    /// If there is a value for this field, forc will try to update the proxy contract's storage
+    /// field such that it points to current contract's deployed instance.
+    pub address: Option<String>,
+}
+
 impl DependencyDetails {
     /// Checks if dependency details reserved for a specific dependency type used without the main
     /// detail for that type.
@@ -650,6 +662,11 @@ impl PackageManifest {
             .and_then(|patches| patches.get(patch_name))
     }
 
+    /// Retrieve the proxy table for the package.
+    pub fn proxy(&self) -> Option<&Proxy> {
+        self.proxy.as_ref()
+    }
+
     /// Check for the `core` and `std` packages under `[dependencies]`. If both are missing, add
     /// `std` implicitly.
     ///
diff --git a/forc-pkg/src/pkg.rs b/forc-pkg/src/pkg.rs
index 09b00fa5057..9467b483b2e 100644
--- a/forc-pkg/src/pkg.rs
+++ b/forc-pkg/src/pkg.rs
@@ -9,12 +9,12 @@ use crate::{
     BuildProfile,
 };
 use anyhow::{anyhow, bail, Context, Error, Result};
-use forc_tracing::println_warning;
+use byte_unit::{Byte, UnitType};
+use forc_tracing::{println_action_green, println_warning};
 use forc_util::{
     default_output_directory, find_file_name, kebab_to_snake_case, print_compiling,
     print_on_failure, print_warnings,
 };
-use fuel_abi_types::abi::program as program_abi;
 use petgraph::{
     self, dot,
     visit::{Bfs, Dfs, EdgeRef, Walker},
@@ -241,8 +241,6 @@ pub struct PkgOpts {
     ///
     /// By default, this is `<project-root>/out`.
     pub output_directory: Option<String>,
-    /// Outputs json abi with callpath instead of struct and enum names.
-    pub json_abi_with_callpaths: bool,
     /// The IPFS node to be used for fetching IPFS sources.
     pub ipfs_node: IPFSNode,
 }
@@ -262,6 +260,8 @@ pub struct PrintOpts {
     pub asm: PrintAsm,
     /// Print the bytecode. This is the final output of the compiler.
     pub bytecode: bool,
+    /// Print the original source code together with bytecode.
+    pub bytecode_spans: bool,
     /// Print the generated Sway IR (Intermediate Representation).
     pub ir: PrintIr,
     /// Output build errors and warnings in reverse order.
@@ -282,7 +282,7 @@ pub struct MinifyOpts {
 type ContractIdConst = String;
 
 /// The set of options provided to the `build` functions.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct BuildOpts {
     pub pkg: PkgOpts,
     pub print: PrintOpts,
@@ -315,6 +315,7 @@ pub struct BuildOpts {
 }
 
 /// The set of options to filter type of projects to build in a workspace.
+#[derive(Clone)]
 pub struct MemberFilter {
     pub build_contracts: bool,
     pub build_scripts: bool,
@@ -497,7 +498,11 @@ impl BuiltPackage {
         let json_abi_path = output_dir.join(program_abi_stem).with_extension("json");
         self.write_json_abi(&json_abi_path, minify)?;
 
-        info!("      Bytecode size: {} bytes", self.bytecode.bytes.len());
+        debug!(
+            "      Bytecode size: {} bytes ({})",
+            self.bytecode.bytes.len(),
+            format_bytecode_size(self.bytecode.bytes.len())
+        );
         // Additional ops required depending on the program type
         match self.tree_type {
             TreeType::Contract => {
@@ -531,7 +536,7 @@ impl BuiltPackage {
                 let hash_file_name = format!("{}{}", &pkg_name, SWAY_BIN_HASH_SUFFIX);
                 let hash_path = output_dir.join(hash_file_name);
                 fs::write(hash_path, &bytecode_hash)?;
-                info!("      Bytecode hash: {}", bytecode_hash);
+                debug!("      Bytecode hash: {}", bytecode_hash);
             }
             _ => (),
         }
@@ -575,8 +580,8 @@ impl BuildPlan {
     ///
     /// To do so, it tries to read the manifet file at the target path and creates the plan with
     /// `BuildPlan::from_lock_and_manifest`.
-    pub fn from_build_opts(build_options: &BuildOpts) -> Result<Self> {
-        let path = &build_options.pkg.path;
+    pub fn from_pkg_opts(pkg_options: &PkgOpts) -> Result<Self> {
+        let path = &pkg_options.path;
 
         let manifest_dir = if let Some(ref path) = path {
             PathBuf::from(path)
@@ -594,9 +599,9 @@ impl BuildPlan {
         Self::from_lock_and_manifests(
             &lock_path,
             &member_manifests,
-            build_options.pkg.locked,
-            build_options.pkg.offline,
-            &build_options.pkg.ipfs_node,
+            pkg_options.locked,
+            pkg_options.offline,
+            &pkg_options.ipfs_node,
         )
     }
 
@@ -713,7 +718,10 @@ impl BuildPlan {
                     cause,
                 );
             }
-            info!("  Creating a new `Forc.lock` file. (Cause: {})", cause);
+            println_action_green(
+                "Creating",
+                &format!("a new `Forc.lock` file. (Cause: {})", cause),
+            );
             let member_names = manifests
                 .iter()
                 .map(|(_, manifest)| manifest.project.name.to_string())
@@ -723,7 +731,7 @@ impl BuildPlan {
                 .map_err(|e| anyhow!("failed to serialize lock file: {}", e))?;
             fs::write(lock_path, string)
                 .map_err(|e| anyhow!("failed to write lock file: {}", e))?;
-            info!("   Created new lock file at {}", lock_path.display());
+            debug!("   Created new lock file at {}", lock_path.display());
         }
 
         Ok(plan)
@@ -1549,7 +1557,10 @@ pub fn sway_build_config(
     .with_print_dca_graph(build_profile.print_dca_graph.clone())
     .with_print_dca_graph_url_format(build_profile.print_dca_graph_url_format.clone())
     .with_print_asm(build_profile.print_asm)
-    .with_print_bytecode(build_profile.print_bytecode)
+    .with_print_bytecode(
+        build_profile.print_bytecode,
+        build_profile.print_bytecode_spans,
+    )
     .with_print_ir(build_profile.print_ir.clone())
     .with_include_tests(build_profile.include_tests)
     .with_time_phases(build_profile.time_phases)
@@ -1587,18 +1598,19 @@ pub fn dependency_namespace(
 ) -> Result<namespace::Root, vec1::Vec1<CompileError>> {
     // TODO: Clean this up when config-time constants v1 are removed.
     let node_idx = &graph[node];
-    let name = Some(Ident::new_no_span(node_idx.name.clone()));
+    let name = Ident::new_no_span(node_idx.name.clone());
     let mut root_module = if let Some(contract_id_value) = contract_id_value {
-        namespace::default_with_contract_id(engines, name.clone(), contract_id_value, experimental)?
+        namespace::default_with_contract_id(
+            engines,
+            name.clone(),
+            Visibility::Public,
+            contract_id_value,
+            experimental,
+        )?
     } else {
-        namespace::Module::default()
+        namespace::Module::new(name, Visibility::Public, None)
     };
 
-    root_module.write(engines, |root_module| {
-        root_module.name.clone_from(&name);
-        root_module.visibility = Visibility::Public;
-    });
-
     // Add direct dependencies.
     let mut core_added = false;
     for edge in graph.edges_directed(node, Direction::Outgoing) {
@@ -1620,16 +1632,14 @@ pub fn dependency_namespace(
                 // Construct namespace with contract id
                 let contract_id_value = format!("0x{dep_contract_id}");
                 let node_idx = &graph[dep_node];
-                let name = Some(Ident::new_no_span(node_idx.name.clone()));
-                let mut module = namespace::default_with_contract_id(
+                let name = Ident::new_no_span(node_idx.name.clone());
+                namespace::default_with_contract_id(
                     engines,
                     name.clone(),
+                    Visibility::Private,
                     contract_id_value,
                     experimental,
-                )?;
-                module.name = name;
-                module.visibility = Visibility::Public;
-                module
+                )?
             }
         };
         dep_namespace.is_external = true;
@@ -1652,20 +1662,22 @@ pub fn dependency_namespace(
     let mut root = namespace::Root::from(root_module);
 
     if core_added {
-        let _ = root.star_import_with_reexports(
+        let _ = root.star_import(
             &Handler::default(),
             engines,
             &[CORE, PRELUDE].map(|s| Ident::new_no_span(s.into())),
             &[],
+            Visibility::Private,
         );
     }
 
     if has_std_dep(graph, node) {
-        let _ = root.star_import_with_reexports(
+        let _ = root.star_import(
             &Handler::default(),
             engines,
             &[STD, PRELUDE].map(|s| Ident::new_no_span(s.into())),
             &[],
+            Visibility::Private,
         );
     }
 
@@ -1746,7 +1758,7 @@ pub fn compile(
     pkg: &PackageDescriptor,
     profile: &BuildProfile,
     engines: &Engines,
-    namespace: namespace::Root,
+    namespace: &mut namespace::Root,
     source_map: &mut SourceMap,
 ) -> Result<CompiledPackage> {
     let mut metrics = PerformanceData::default();
@@ -1818,29 +1830,38 @@ pub fn compile(
         metrics
     );
 
+    const OLD_ENCODING_VERSION: &str = "0";
     const NEW_ENCODING_VERSION: &str = "1";
+    const SPEC_VERSION: &str = "1";
 
     let mut program_abi = match pkg.target {
         BuildTarget::Fuel => {
-            let mut types = vec![];
-            ProgramABI::Fuel(time_expr!(
+            let program_abi_res = time_expr!(
                 "generate JSON ABI program",
                 "generate_json_abi",
                 fuel_abi::generate_program_abi(
+                    &handler,
                     &mut AbiContext {
                         program: typed_program,
-                        abi_with_callpaths: profile.json_abi_with_callpaths,
+                        abi_with_callpaths: true,
+                        type_ids_to_full_type_str: HashMap::<String, String>::new(),
                     },
                     engines,
-                    &mut types,
                     profile
                         .experimental
                         .new_encoding
-                        .then(|| NEW_ENCODING_VERSION.into()),
+                        .then(|| NEW_ENCODING_VERSION.into())
+                        .unwrap_or(OLD_ENCODING_VERSION.into()),
+                    SPEC_VERSION.into(),
                 ),
                 Some(sway_build_config.clone()),
                 metrics
-            ))
+            );
+            let program_abi = match program_abi_res {
+                Err(_) => return fail(handler),
+                Ok(program_abi) => program_abi,
+            };
+            ProgramABI::Fuel(program_abi)
         }
         BuildTarget::EVM => {
             // Merge the ABI output of ASM gen with ABI gen to handle internal constructors
@@ -1865,8 +1886,6 @@ pub fn compile(
 
             ProgramABI::Evm(ops)
         }
-
-        BuildTarget::MidenVM => ProgramABI::MidenVM(()),
     };
 
     let entries = asm_res
@@ -2079,13 +2098,13 @@ fn build_profile_from_opts(
     profile.print_ir |= print.ir.clone();
     profile.print_asm |= print.asm;
     profile.print_bytecode |= print.bytecode;
+    profile.print_bytecode_spans |= print.bytecode_spans;
     profile.terse |= pkg.terse;
     profile.time_phases |= time_phases;
     if profile.metrics_outfile.is_none() {
         profile.metrics_outfile.clone_from(metrics_outfile);
     }
     profile.include_tests |= tests;
-    profile.json_abi_with_callpaths |= pkg.json_abi_with_callpaths;
     profile.error_on_warnings |= error_on_warnings;
     profile.experimental = ExperimentalFlags {
         new_encoding: experimental.new_encoding,
@@ -2104,6 +2123,12 @@ fn profile_target_string(profile_name: &str, build_target: &BuildTarget) -> Stri
     };
     format!("{profile_name} [{}] target(s)", targets.join(" + "))
 }
+/// Returns the size of the bytecode in a human-readable format.
+pub fn format_bytecode_size(bytes_len: usize) -> String {
+    let size = Byte::from_u64(bytes_len as u64);
+    let adjusted_byte = size.get_appropriate_unit(UnitType::Decimal);
+    adjusted_byte.to_string()
+}
 
 /// Check if the given node is a contract dependency of any node in the graph.
 fn is_contract_dependency(graph: &Graph, node: NodeIx) -> bool {
@@ -2132,7 +2157,9 @@ pub fn build_with_options(build_options: &BuildOpts) -> Result<Built> {
         .as_ref()
         .map_or_else(|| current_dir, PathBuf::from);
 
-    let build_plan = BuildPlan::from_build_opts(build_options)?;
+    println_action_green("Building", &path.display().to_string());
+
+    let build_plan = BuildPlan::from_pkg_opts(&build_options.pkg)?;
     let graph = build_plan.graph();
     let manifest_map = build_plan.manifest_map();
 
@@ -2170,12 +2197,19 @@ pub fn build_with_options(build_options: &BuildOpts) -> Result<Built> {
         },
     )?;
     let output_dir = pkg.output_directory.as_ref().map(PathBuf::from);
-
-    let finished = ansi_term::Colour::Green.bold().paint("Finished");
-    info!(
-        "  {finished} {} in {:.2}s",
-        profile_target_string(&build_profile.name, build_target),
-        build_start.elapsed().as_secs_f32()
+    let total_size = built_packages
+        .iter()
+        .map(|(_, pkg)| pkg.bytecode.bytes.len())
+        .sum::<usize>();
+
+    println_action_green(
+        "Finished",
+        &format!(
+            "{} [{}] in {:.2}s",
+            profile_target_string(&build_profile.name, build_target),
+            format_bytecode_size(total_size),
+            build_start.elapsed().as_secs_f32()
+        ),
     );
     for (node_ix, built_package) in built_packages {
         print_pkg_summary_header(&built_package);
@@ -2289,6 +2323,7 @@ pub fn build(
 
     let mut lib_namespace_map = HashMap::default();
     let mut compiled_contract_deps = HashMap::new();
+
     for &node in plan
         .compilation_order
         .iter()
@@ -2343,7 +2378,7 @@ pub fn build(
 
             // `ContractIdConst` is a None here since we do not yet have a
             // contract ID value at this point.
-            let dep_namespace = match dependency_namespace(
+            let mut dep_namespace = match dependency_namespace(
                 &lib_namespace_map,
                 &compiled_contract_deps,
                 plan.graph(),
@@ -2360,7 +2395,7 @@ pub fn build(
                 &descriptor,
                 &profile,
                 &engines,
-                dep_namespace,
+                &mut dep_namespace,
                 &mut source_map,
             )?;
 
@@ -2407,7 +2442,7 @@ pub fn build(
         };
 
         // Note that the contract ID value here is only Some if tests are enabled.
-        let dep_namespace = match dependency_namespace(
+        let mut dep_namespace = match dependency_namespace(
             &lib_namespace_map,
             &compiled_contract_deps,
             plan.graph(),
@@ -2429,11 +2464,11 @@ pub fn build(
             }
         };
 
-        let mut compiled = compile(
+        let compiled = compile(
             &descriptor,
             &profile,
             &engines,
-            dep_namespace,
+            &mut dep_namespace,
             &mut source_map,
         )?;
 
@@ -2445,18 +2480,10 @@ pub fn build(
         }
 
         if let TreeType::Library = compiled.tree_type {
-            compiled.root_module.write(&engines, |root_module| {
-                root_module.name = Some(Ident::new_no_span(pkg.name.clone()));
-            });
             lib_namespace_map.insert(node, compiled.root_module);
         }
         source_map.insert_dependency(descriptor.manifest_file.dir());
 
-        // TODO: This should probably be in `fuel_abi_json::generate_json_abi_program`?
-        if let ProgramABI::Fuel(ref mut program_abi) = compiled.program_abi {
-            standardize_json_abi_types(program_abi);
-        }
-
         let built_pkg = BuiltPackage {
             descriptor,
             program_abi: compiled.program_abi,
@@ -2476,136 +2503,6 @@ pub fn build(
     Ok(built_packages)
 }
 
-/// Standardize the JSON ABI data structure by eliminating duplicate types. This is an iterative
-/// process because every time two types are merged, new opportunities for more merging arise.
-fn standardize_json_abi_types(json_abi_program: &mut program_abi::ProgramABI) {
-    loop {
-        // If type with id_1 is a duplicate of type with id_2, then keep track of the mapping
-        // between id_1 and id_2 in the HashMap below.
-        let mut old_to_new_id: HashMap<usize, usize> = HashMap::new();
-
-        // A vector containing unique `program_abi::TypeDeclaration`s.
-        //
-        // Two `program_abi::TypeDeclaration` are deemed the same if the have the same
-        // `type_field`, `components`, and `type_parameters` (even if their `type_id`s are
-        // different).
-        let mut deduped_types: Vec<program_abi::TypeDeclaration> = Vec::new();
-
-        // Insert values in `deduped_types` if they haven't been inserted before. Otherwise, create
-        // an appropriate mapping between type IDs in the HashMap `old_to_new_id`.
-        for decl in &json_abi_program.types {
-            if let Some(ty) = deduped_types.iter().find(|d| {
-                d.type_field == decl.type_field
-                    && d.components == decl.components
-                    && d.type_parameters == decl.type_parameters
-            }) {
-                old_to_new_id.insert(decl.type_id, ty.type_id);
-            } else {
-                deduped_types.push(decl.clone());
-            }
-        }
-
-        // Nothing to do if the hash map is empty as there are not merge opportunities. We can now
-        // exit the loop.
-        if old_to_new_id.is_empty() {
-            break;
-        }
-
-        json_abi_program.types = deduped_types;
-
-        // Update all `program_abi::TypeApplication`s and all `program_abi::TypeDeclaration`s
-        update_all_types(json_abi_program, &old_to_new_id);
-    }
-
-    // Sort the `program_abi::TypeDeclaration`s
-    json_abi_program
-        .types
-        .sort_by(|t1, t2| t1.type_field.cmp(&t2.type_field));
-
-    // Standardize IDs (i.e. change them to 0,1,2,... according to the alphabetical order above
-    let mut old_to_new_id: HashMap<usize, usize> = HashMap::new();
-    for (ix, decl) in json_abi_program.types.iter_mut().enumerate() {
-        old_to_new_id.insert(decl.type_id, ix);
-        decl.type_id = ix;
-    }
-
-    // Update all `program_abi::TypeApplication`s and all `program_abi::TypeDeclaration`s
-    update_all_types(json_abi_program, &old_to_new_id);
-}
-
-/// Recursively updates the type IDs used in a program_abi::ProgramABI
-fn update_all_types(
-    json_abi_program: &mut program_abi::ProgramABI,
-    old_to_new_id: &HashMap<usize, usize>,
-) {
-    // Update all `program_abi::TypeApplication`s in every function
-    for func in &mut json_abi_program.functions {
-        for input in &mut func.inputs {
-            update_json_type_application(input, old_to_new_id);
-        }
-
-        update_json_type_application(&mut func.output, old_to_new_id);
-    }
-
-    // Update all `program_abi::TypeDeclaration`
-    for decl in &mut json_abi_program.types {
-        update_json_type_declaration(decl, old_to_new_id);
-    }
-    if let Some(logged_types) = &mut json_abi_program.logged_types {
-        for logged_type in logged_types {
-            update_json_type_application(&mut logged_type.application, old_to_new_id);
-        }
-    }
-    if let Some(messages_types) = &mut json_abi_program.messages_types {
-        for logged_type in messages_types {
-            update_json_type_application(&mut logged_type.application, old_to_new_id);
-        }
-    }
-    if let Some(configurables) = &mut json_abi_program.configurables {
-        for logged_type in configurables {
-            update_json_type_application(&mut logged_type.application, old_to_new_id);
-        }
-    }
-}
-
-/// Recursively updates the type IDs used in a `program_abi::TypeApplication` given a HashMap from
-/// old to new IDs
-fn update_json_type_application(
-    type_application: &mut program_abi::TypeApplication,
-    old_to_new_id: &HashMap<usize, usize>,
-) {
-    if let Some(new_id) = old_to_new_id.get(&type_application.type_id) {
-        type_application.type_id = *new_id;
-    }
-
-    if let Some(args) = &mut type_application.type_arguments {
-        for arg in args.iter_mut() {
-            update_json_type_application(arg, old_to_new_id);
-        }
-    }
-}
-
-/// Recursively updates the type IDs used in a `program_abi::TypeDeclaration` given a HashMap from
-/// old to new IDs
-fn update_json_type_declaration(
-    type_declaration: &mut program_abi::TypeDeclaration,
-    old_to_new_id: &HashMap<usize, usize>,
-) {
-    if let Some(params) = &mut type_declaration.type_parameters {
-        for param in params.iter_mut() {
-            if let Some(new_id) = old_to_new_id.get(param) {
-                *param = *new_id;
-            }
-        }
-    }
-
-    if let Some(components) = &mut type_declaration.components {
-        for component in components.iter_mut() {
-            update_json_type_application(component, old_to_new_id);
-        }
-    }
-}
-
 /// Compile the entire forc package and return the lexed, parsed and typed programs
 /// of the dependencies and project.
 /// The final item in the returned vector is the project.
@@ -2642,7 +2539,7 @@ pub fn check(
         let contract_id_value =
             (idx == plan.compilation_order.len() - 1).then(|| DUMMY_CONTRACT_ID.to_string());
 
-        let dep_namespace = dependency_namespace(
+        let mut dep_namespace = dependency_namespace(
             &lib_namespace_map,
             &compiled_contract_deps,
             &plan.graph,
@@ -2673,7 +2570,7 @@ pub fn check(
             &handler,
             engines,
             input,
-            dep_namespace,
+            &mut dep_namespace,
             Some(&build_config),
             &pkg.name,
             retrigger_compilation.clone(),
@@ -2701,8 +2598,7 @@ pub fn check(
                     .namespace
                     .program_id(engines)
                     .read(engines, |m| m.clone());
-                module.name = Some(Ident::new_no_span(pkg.name.clone()));
-                module.span = Some(
+                module.set_span(
                     Span::new(
                         manifest.entry_string()?,
                         0,
diff --git a/forc-pkg/src/source/git/mod.rs b/forc-pkg/src/source/git/mod.rs
index fdaf0b8a8b0..a89e77f3128 100644
--- a/forc-pkg/src/source/git/mod.rs
+++ b/forc-pkg/src/source/git/mod.rs
@@ -6,6 +6,7 @@ use crate::{
     source,
 };
 use anyhow::{anyhow, bail, Context, Result};
+use forc_tracing::println_action_green;
 use forc_util::git_checkouts_directory;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
@@ -15,7 +16,6 @@ use std::{
     path::{Path, PathBuf},
     str::FromStr,
 };
-use tracing::info;
 
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Deserialize, Serialize)]
 pub struct Url {
@@ -204,11 +204,13 @@ impl source::Fetch for Pinned {
         {
             let _guard = lock.write()?;
             if !repo_path.exists() {
-                info!(
-                    "  {} {} {}",
-                    ansi_term::Color::Green.bold().paint("Fetching"),
-                    ansi_term::Style::new().bold().paint(ctx.name),
-                    self
+                println_action_green(
+                    "Fetching",
+                    &format!(
+                        "{} {}",
+                        ansi_term::Style::new().bold().paint(ctx.name),
+                        self
+                    ),
                 );
                 fetch(ctx.fetch_id(), ctx.name(), self)?;
             }
diff --git a/forc-pkg/src/source/ipfs.rs b/forc-pkg/src/source/ipfs.rs
index 70dc988588d..1391348834c 100644
--- a/forc-pkg/src/source/ipfs.rs
+++ b/forc-pkg/src/source/ipfs.rs
@@ -4,6 +4,7 @@ use crate::{
     source,
 };
 use anyhow::Result;
+use forc_tracing::println_action_green;
 use futures::TryStreamExt;
 use ipfs_api::IpfsApi;
 use ipfs_api_backend_hyper as ipfs_api;
@@ -14,7 +15,6 @@ use std::{
     str::FromStr,
 };
 use tar::Archive;
-use tracing::info;
 
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Cid(cid::Cid);
@@ -67,11 +67,13 @@ impl source::Fetch for Pinned {
         {
             let _guard = lock.write()?;
             if !repo_path.exists() {
-                info!(
-                    "  {} {} {}",
-                    ansi_term::Color::Green.bold().paint("Fetching"),
-                    ansi_term::Style::new().bold().paint(ctx.name),
-                    self
+                println_action_green(
+                    "Fetching",
+                    &format!(
+                        "{} {}",
+                        ansi_term::Style::new().bold().paint(ctx.name),
+                        self
+                    ),
                 );
                 let cid = &self.0;
                 let ipfs_client = ipfs_client();
@@ -79,17 +81,16 @@ impl source::Fetch for Pinned {
                 futures::executor::block_on(async {
                     match ctx.ipfs_node() {
                         source::IPFSNode::Local => {
-                            info!(
-                                "   {} with local IPFS node",
-                                ansi_term::Color::Green.bold().paint("Fetching")
-                            );
+                            println_action_green("Fetching", "with local IPFS node");
                             cid.fetch_with_client(&ipfs_client, &dest).await
                         }
                         source::IPFSNode::WithUrl(ipfs_node_gateway_url) => {
-                            info!(
-                                "   {} from {}. Note: This can take several minutes.",
-                                ansi_term::Color::Green.bold().paint("Fetching"),
-                                ipfs_node_gateway_url
+                            println_action_green(
+                                "Fetching",
+                                &format!(
+                                    "from {}. Note: This can take several minutes.",
+                                    ipfs_node_gateway_url
+                                ),
                             );
                             cid.fetch_with_gateway_url(ipfs_node_gateway_url, &dest)
                                 .await
@@ -136,7 +137,7 @@ impl Cid {
     /// Using local node, fetches the content described by this cid.
     async fn fetch_with_client(&self, ipfs_client: &IpfsClient, dst: &Path) -> Result<()> {
         let cid_path = format!("/ipfs/{}", self.0);
-        // Since we are fetching packages as a fodler, they are returned as a tar archive.
+        // Since we are fetching packages as a folder, they are returned as a tar archive.
         let bytes = ipfs_client
             .get(&cid_path)
             .map_ok(|chunk| chunk.to_vec())
diff --git a/forc-pkg/tests/sections/Forc.toml b/forc-pkg/tests/sections/Forc.toml
index e4d70be8857..88b012cd138 100644
--- a/forc-pkg/tests/sections/Forc.toml
+++ b/forc-pkg/tests/sections/Forc.toml
@@ -17,7 +17,6 @@ terse = true
 time-phases = true
 metrics-outfile = "metrics_outfile"
 include-tests = true
-json-abi-with-callpaths = true
 error-on-warnings = true
 reverse-results = true
 optimization-level = 0
diff --git a/forc-plugins/forc-client/Cargo.toml b/forc-plugins/forc-client/Cargo.toml
index 521c6e03f13..ee1b03ea173 100644
--- a/forc-plugins/forc-client/Cargo.toml
+++ b/forc-plugins/forc-client/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-client"
-version = "0.60.0"
+version.workspace = true
 description = "A `forc` plugin for interacting with a Fuel node."
 authors.workspace = true
 edition.workspace = true
@@ -9,36 +9,51 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1"
-async-trait = "0.1.58"
-chrono = { version = "0.4", default-features = false, features = ["std"] }
-clap = { version = "4.5.4", features = ["derive", "env"] }
-devault = "0.1"
-forc = { version = "0.60.0", path = "../../forc" }
-forc-pkg = { version = "0.60.0", path = "../../forc-pkg" }
-forc-tracing = { version = "0.60.0", path = "../../forc-tracing" }
-forc-tx = { version = "0.60.0", path = "../forc-tx" }
-forc-util = { version = "0.60.0", path = "../../forc-util" }
-forc-wallet = { workspace = true }
-fuel-abi-types = { workspace = true }
+anyhow.workspace = true
+async-trait.workspace = true
+aws-config.workspace = true
+aws-sdk-kms.workspace = true
+chrono = { workspace = true, features = ["std"] }
+clap = { workspace = true, features = ["derive", "env"] }
+devault.workspace = true
+dialoguer.workspace = true
+forc.workspace = true
+forc-pkg.workspace = true
+forc-tracing.workspace = true
+forc-tx.workspace = true
+forc-util.workspace = true
+forc-wallet.workspace = true
+fuel-abi-types.workspace = true
 fuel-core-client = { workspace = true, features = ["subscriptions"] }
-fuel-core-types = { workspace = true }
-fuel-crypto = { workspace = true }
+fuel-core-types.workspace = true
+fuel-crypto.workspace = true
 fuel-tx = { workspace = true, features = ["test-helpers"] }
-fuel-vm = { workspace = true }
-fuels-accounts = { workspace = true }
-fuels-core = { workspace = true }
-futures = "0.3"
-hex = "0.4.3"
-rand = "0.8"
-rpassword = "7.2"
-serde = "1.0"
-serde_json = "1"
-sway-core = { version = "0.60.0", path = "../../sway-core" }
-sway-types = { version = "0.60.0", path = "../../sway-types" }
-sway-utils = { version = "0.60.0", path = "../../sway-utils" }
-tokio = { version = "1.8", features = ["macros", "rt-multi-thread", "process"] }
-tracing = "0.1"
+fuel-vm.workspace = true
+fuels.workspace = true
+fuels-accounts.workspace = true
+fuels-core.workspace = true
+futures.workspace = true
+hex.workspace = true
+k256.workspace = true
+rand.workspace = true
+rpassword.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sway-core.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+tokio = { workspace = true, features = ["macros", "process", "rt-multi-thread"] }
+toml_edit.workspace = true
+tracing.workspace = true
+
+[dev-dependencies]
+portpicker = "0.1.1"
+pretty_assertions = "1.4.1"
+rexpect = "0.5"
+tempfile = "3"
+
+[build-dependencies]
+regex = "1.5.4"
 
 [[bin]]
 name = "forc-deploy"
diff --git a/forc-plugins/forc-client/build.rs b/forc-plugins/forc-client/build.rs
new file mode 100644
index 00000000000..00e28aaef3a
--- /dev/null
+++ b/forc-plugins/forc-client/build.rs
@@ -0,0 +1,79 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+fn minify_json(json: &str) -> String {
+    let mut result = String::with_capacity(json.len());
+    let mut in_string = false;
+    let mut previous_char: Option<char> = None;
+
+    for c in json.chars() {
+        if in_string {
+            result.push(c);
+            if c == '"' && previous_char != Some('\\') {
+                in_string = false;
+            }
+        } else {
+            match c {
+                '"' => {
+                    result.push(c);
+                    in_string = true;
+                }
+                ' ' | '\n' | '\r' | '\t' => continue, // Skip whitespace
+                _ => result.push(c),
+            }
+        }
+        previous_char = Some(c);
+    }
+    result
+}
+
+fn update_proxy_abi_decl_with_file(source_file_path: &Path, minified_json: &str) {
+    // Read the contents of the source file
+    let mut source_code = fs::read_to_string(source_file_path).expect("Unable to read source file");
+
+    // Prepare the replacement string for the `abigen!` macro
+    let escaped_json = minified_json.replace('\\', "\\\\").replace('"', "\\\"");
+    let new_abigen = format!(
+        "abigen!(Contract(name = \"ProxyContract\", abi = \"{}\",));",
+        escaped_json
+    );
+
+    // Use a regular expression to find and replace the `abigen!` macro
+    let re = regex::Regex::new(r#"abigen!\(Contract\(name = "ProxyContract", abi = ".*?",\)\);"#)
+        .expect("Invalid regex pattern");
+
+    // Replace the existing `abigen!` macro with the new one containing the updated ABI
+    if re.is_match(&source_code) {
+        source_code = re.replace(&source_code, new_abigen.as_str()).to_string();
+    } else {
+        panic!("abigen! macro not found in the source file");
+    }
+
+    // Write the modified source code back to the source file
+    fs::write(source_file_path, source_code).expect("Unable to write back to the source file");
+}
+
+fn main() {
+    // Path to the JSON file in the root directory next to the `src` folder
+    let json_path = PathBuf::from("proxy_abi/proxy_contract-abi.json");
+    // Read the contents of the JSON file
+    let json_content =
+        fs::read_to_string(json_path).expect("Unable to read proxy_contract-abi.json");
+
+    // Minify the JSON content
+    let minified_json = minify_json(&json_content);
+
+    // If proxy_contract-abi.json is changed, re-run this script
+    println!("cargo:rerun-if-changed=proxy_abi/proxy_contract-abi.json");
+
+    // Path to the Rust source file that contains the `abigen!` macro that
+    // creates a `ProxyContract`.
+    let util_tx_path = PathBuf::from("src/util/tx.rs");
+    update_proxy_abi_decl_with_file(&util_tx_path, &minified_json);
+
+    let test_path = PathBuf::from("tests/deploy.rs");
+    update_proxy_abi_decl_with_file(&test_path, &minified_json);
+
+    let deploy_path = PathBuf::from("src/op/deploy.rs");
+    update_proxy_abi_decl_with_file(&deploy_path, &minified_json);
+}
diff --git a/forc-plugins/forc-client/proxy_abi/README.md b/forc-plugins/forc-client/proxy_abi/README.md
new file mode 100644
index 00000000000..684e8ceff17
--- /dev/null
+++ b/forc-plugins/forc-client/proxy_abi/README.md
@@ -0,0 +1,8 @@
+# Proxy Contract
+
+This folder contains pre-built version of the owned proxy contract, its abi and `storage-slots.json` file.
+
+*contract url*: [sway-standard-implementation/src-14/owned_proxy](https://github.com/FuelLabs/sway-standard-implementations/tree/174f5ed9c79c23a6aaf5db906fe27ecdb29c22eb).
+*commit hash*: `174f5ed9c79c23a6aaf5db906fe27ecdb29c22eb`
+*forc version*: `v0.63.6`
+*build command*: `forc build --release`
diff --git a/forc-plugins/forc-client/proxy_abi/proxy_contract-abi.json b/forc-plugins/forc-client/proxy_abi/proxy_contract-abi.json
new file mode 100644
index 00000000000..9fa09e507ba
--- /dev/null
+++ b/forc-plugins/forc-client/proxy_abi/proxy_contract-abi.json
@@ -0,0 +1,724 @@
+{
+  "programType": "contract",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
+    {
+      "type": "()",
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    },
+    {
+      "type": "enum standards::src5::AccessError",
+      "concreteTypeId": "3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d",
+      "metadataTypeId": 1
+    },
+    {
+      "type": "enum standards::src5::State",
+      "concreteTypeId": "192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c",
+      "metadataTypeId": 2
+    },
+    {
+      "type": "enum std::option::Option<struct std::contract_id::ContractId>",
+      "concreteTypeId": "0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8",
+      "metadataTypeId": 4,
+      "typeArguments": [
+        "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54"
+      ]
+    },
+    {
+      "type": "enum sway_libs::ownership::errors::InitializationError",
+      "concreteTypeId": "1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893",
+      "metadataTypeId": 5
+    },
+    {
+      "type": "enum sway_libs::upgradability::errors::SetProxyOwnerError",
+      "concreteTypeId": "3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74",
+      "metadataTypeId": 6
+    },
+    {
+      "type": "str",
+      "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a"
+    },
+    {
+      "type": "struct std::contract_id::ContractId",
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "metadataTypeId": 9
+    },
+    {
+      "type": "struct sway_libs::upgradability::events::ProxyOwnerSet",
+      "concreteTypeId": "96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247",
+      "metadataTypeId": 10
+    },
+    {
+      "type": "struct sway_libs::upgradability::events::ProxyTargetSet",
+      "concreteTypeId": "1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8",
+      "metadataTypeId": 11
+    }
+  ],
+  "metadataTypes": [
+    {
+      "type": "b256",
+      "metadataTypeId": 0
+    },
+    {
+      "type": "enum standards::src5::AccessError",
+      "metadataTypeId": 1,
+      "components": [
+        {
+          "name": "NotOwner",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        }
+      ]
+    },
+    {
+      "type": "enum standards::src5::State",
+      "metadataTypeId": 2,
+      "components": [
+        {
+          "name": "Uninitialized",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        },
+        {
+          "name": "Initialized",
+          "typeId": 3
+        },
+        {
+          "name": "Revoked",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        }
+      ]
+    },
+    {
+      "type": "enum std::identity::Identity",
+      "metadataTypeId": 3,
+      "components": [
+        {
+          "name": "Address",
+          "typeId": 8
+        },
+        {
+          "name": "ContractId",
+          "typeId": 9
+        }
+      ]
+    },
+    {
+      "type": "enum std::option::Option",
+      "metadataTypeId": 4,
+      "components": [
+        {
+          "name": "None",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        },
+        {
+          "name": "Some",
+          "typeId": 7
+        }
+      ],
+      "typeParameters": [
+        7
+      ]
+    },
+    {
+      "type": "enum sway_libs::ownership::errors::InitializationError",
+      "metadataTypeId": 5,
+      "components": [
+        {
+          "name": "CannotReinitialized",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        }
+      ]
+    },
+    {
+      "type": "enum sway_libs::upgradability::errors::SetProxyOwnerError",
+      "metadataTypeId": 6,
+      "components": [
+        {
+          "name": "CannotUninitialize",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        }
+      ]
+    },
+    {
+      "type": "generic T",
+      "metadataTypeId": 7
+    },
+    {
+      "type": "struct std::address::Address",
+      "metadataTypeId": 8,
+      "components": [
+        {
+          "name": "bits",
+          "typeId": 0
+        }
+      ]
+    },
+    {
+      "type": "struct std::contract_id::ContractId",
+      "metadataTypeId": 9,
+      "components": [
+        {
+          "name": "bits",
+          "typeId": 0
+        }
+      ]
+    },
+    {
+      "type": "struct sway_libs::upgradability::events::ProxyOwnerSet",
+      "metadataTypeId": 10,
+      "components": [
+        {
+          "name": "new_proxy_owner",
+          "typeId": 2
+        }
+      ]
+    },
+    {
+      "type": "struct sway_libs::upgradability::events::ProxyTargetSet",
+      "metadataTypeId": 11,
+      "components": [
+        {
+          "name": "new_target",
+          "typeId": 9
+        }
+      ]
+    }
+  ],
+  "functions": [
+    {
+      "inputs": [],
+      "name": "proxy_target",
+      "output": "0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8",
+      "attributes": [
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " Returns the target contract of the proxy contract."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Returns"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * [Option<ContractId>] - The new proxy contract to which all fallback calls will be passed or `None`."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Number of Storage Accesses"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Reads: `1`"
+          ]
+        },
+        {
+          "name": "storage",
+          "arguments": [
+            "read"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "new_target",
+          "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54"
+        }
+      ],
+      "name": "set_proxy_target",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "attributes": [
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " Change the target contract of the proxy contract."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Additional Information"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " This method can only be called by the `proxy_owner`."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Arguments"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * `new_target`: [ContractId] - The new proxy contract to which all fallback calls will be passed."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Reverts"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * When not called by `proxy_owner`."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Number of Storage Accesses"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Reads: `1`"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Write: `1`"
+          ]
+        },
+        {
+          "name": "storage",
+          "arguments": [
+            "read",
+            "write"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [],
+      "name": "proxy_owner",
+      "output": "192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c",
+      "attributes": [
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " Returns the owner of the proxy contract."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Returns"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * [State] - Represents the state of ownership for this contract."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Number of Storage Accesses"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Reads: `1`"
+          ]
+        },
+        {
+          "name": "storage",
+          "arguments": [
+            "read"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [],
+      "name": "initialize_proxy",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "attributes": [
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " Initializes the proxy contract."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Additional Information"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " This method sets the storage values using the values of the configurable constants `INITIAL_TARGET` and `INITIAL_OWNER`."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " This then allows methods that write to storage to be called."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " This method can only be called once."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Reverts"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * When `storage::SRC14.proxy_owner` is not [State::Uninitialized]."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Number of Storage Accesses"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Writes: `2`"
+          ]
+        },
+        {
+          "name": "storage",
+          "arguments": [
+            "write"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "new_proxy_owner",
+          "concreteTypeId": "192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c"
+        }
+      ],
+      "name": "set_proxy_owner",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "attributes": [
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " Changes proxy ownership to the passed State."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Additional Information"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " This method can be used to transfer ownership between Identities or to revoke ownership."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Arguments"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * `new_proxy_owner`: [State] - The new state of the proxy ownership."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Reverts"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * When the sender is not the current proxy owner."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * When the new state of the proxy ownership is [State::Uninitialized]."
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " # Number of Storage Accesses"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            ""
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Reads: `1`"
+          ]
+        },
+        {
+          "name": "doc-comment",
+          "arguments": [
+            " * Writes: `1`"
+          ]
+        },
+        {
+          "name": "storage",
+          "arguments": [
+            "write"
+          ]
+        }
+      ]
+    }
+  ],
+  "loggedTypes": [
+    {
+      "logId": "4571204900286667806",
+      "concreteTypeId": "3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d"
+    },
+    {
+      "logId": "2151606668983994881",
+      "concreteTypeId": "1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8"
+    },
+    {
+      "logId": "2161305517876418151",
+      "concreteTypeId": "1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893"
+    },
+    {
+      "logId": "4354576968059844266",
+      "concreteTypeId": "3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74"
+    },
+    {
+      "logId": "10870989709723147660",
+      "concreteTypeId": "96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247"
+    },
+    {
+      "logId": "10098701174489624218",
+      "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a"
+    }
+  ],
+  "messagesTypes": [],
+  "configurables": [
+    {
+      "name": "INITIAL_TARGET",
+      "concreteTypeId": "0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8",
+      "offset": 13368
+    },
+    {
+      "name": "INITIAL_OWNER",
+      "concreteTypeId": "192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c",
+      "offset": 13320
+    }
+  ]
+}
\ No newline at end of file
diff --git a/forc-plugins/forc-client/proxy_abi/proxy_contract-storage_slots.json b/forc-plugins/forc-client/proxy_abi/proxy_contract-storage_slots.json
new file mode 100644
index 00000000000..72849c97055
--- /dev/null
+++ b/forc-plugins/forc-client/proxy_abi/proxy_contract-storage_slots.json
@@ -0,0 +1,18 @@
+[
+  {
+    "key": "7bb458adc1d118713319a5baa00a2d049dd64d2916477d2688d76970c898cd55",
+    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  {
+    "key": "7bb458adc1d118713319a5baa00a2d049dd64d2916477d2688d76970c898cd56",
+    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  {
+    "key": "bb79927b15d9259ea316f2ecb2297d6cc8851888a98278c0a2e03e1a091ea754",
+    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  {
+    "key": "bb79927b15d9259ea316f2ecb2297d6cc8851888a98278c0a2e03e1a091ea755",
+    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+  }
+]
\ No newline at end of file
diff --git a/forc-plugins/forc-client/proxy_abi/proxy_contract.bin b/forc-plugins/forc-client/proxy_abi/proxy_contract.bin
new file mode 100644
index 00000000000..9ce27196250
Binary files /dev/null and b/forc-plugins/forc-client/proxy_abi/proxy_contract.bin differ
diff --git a/forc-plugins/forc-client/src/cmd/deploy.rs b/forc-plugins/forc-client/src/cmd/deploy.rs
index cf1f26e2a2e..87428dfbca7 100644
--- a/forc-plugins/forc-client/src/cmd/deploy.rs
+++ b/forc-plugins/forc-client/src/cmd/deploy.rs
@@ -10,7 +10,7 @@ forc_util::cli_examples! {
    super::Command {
         [ Deploy a single contract => "forc deploy bc09bfa7a11a04ce42b0a5abf04fd437387ee49bf4561d575177e2946468b408" ]
         [ Deploy a single contract from a different path => "forc deploy bc09bfa7a11a04ce42b0a5abf04fd437387ee49bf4561d575177e2946468b408 --path {path}" ]
-        [ Deploy to a custom network => "forc deploy --node-url https://beta-5.fuel.network/graphql" ]
+        [ Deploy to a custom network => "forc deploy --node-url https://testnet.fuel.network/graphql" ]
     }
 }
 
@@ -55,6 +55,9 @@ pub struct Command {
     /// Deprecated in favor of `--default-signer`.
     #[clap(long)]
     pub unsigned: bool,
+    /// Submit the deployment transaction(s) without waiting for execution to complete.
+    #[clap(long)]
+    pub submit_only: bool,
     /// Set the key to be used for signing.
     pub signing_key: Option<SecretKey>,
     /// Sign the deployment transaction manually.
@@ -84,4 +87,8 @@ pub struct Command {
     /// Disable the "new encoding" feature
     #[clap(long)]
     pub no_encoding_v1: bool,
+
+    /// AWS KMS signer arn. If present forc-deploy will automatically use AWS KMS signer instead of forc-wallet.
+    #[clap(long)]
+    pub aws_kms_signer: Option<String>,
 }
diff --git a/forc-plugins/forc-client/src/cmd/run.rs b/forc-plugins/forc-client/src/cmd/run.rs
index e23d9f6cb43..5875b270adc 100644
--- a/forc-plugins/forc-client/src/cmd/run.rs
+++ b/forc-plugins/forc-client/src/cmd/run.rs
@@ -52,9 +52,6 @@ pub struct Command {
     pub unsigned: bool,
     /// Set the key to be used for signing.
     pub signing_key: Option<SecretKey>,
-    /// Sign the deployment transaction manually.
-    #[clap(long)]
-    pub manual_signing: bool,
     /// Arguments to pass into main function with forc run.
     #[clap(long)]
     pub args: Option<Vec<String>>,
diff --git a/forc-plugins/forc-client/src/constants.rs b/forc-plugins/forc-client/src/constants.rs
index bd946af2f44..1b195f733e6 100644
--- a/forc-plugins/forc-client/src/constants.rs
+++ b/forc-plugins/forc-client/src/constants.rs
@@ -1,14 +1,15 @@
 /// Default to localhost to favour the common case of testing.
 pub const NODE_URL: &str = sway_utils::constants::DEFAULT_NODE_URL;
-pub const BETA_2_ENDPOINT_URL: &str = "https://node-beta-2.fuel.network";
-pub const BETA_3_ENDPOINT_URL: &str = "https://beta-3.fuel.network";
-pub const BETA_4_ENDPOINT_URL: &str = "https://beta-4.fuel.network";
-pub const BETA_5_ENDPOINT_URL: &str = "https://beta-5.fuel.network";
-pub const BETA_2_FAUCET_URL: &str = "https://faucet-beta-2.fuel.network";
-pub const BETA_3_FAUCET_URL: &str = "https://faucet-beta-3.fuel.network";
-pub const BETA_4_FAUCET_URL: &str = "https://faucet-beta-4.fuel.network";
-pub const BETA_5_FAUCET_URL: &str = "https://faucet-beta-5.fuel.network";
-pub const DEVNET_FAUCET_URL: &str = "https://faucet-devnet.fuel.network";
-pub const DEVNET_ENDPOINT_URL: &str = "https://devnet.fuel.network";
-pub const TESTNET_FAUCET_URL: &str = "https://faucet-testnet.fuel.network";
 pub const TESTNET_ENDPOINT_URL: &str = "https://testnet.fuel.network";
+pub const MAINNET_ENDPOINT_URL: &str = "https://mainnet.fuel.network";
+
+pub const TESTNET_FAUCET_URL: &str = "https://faucet-testnet.fuel.network";
+
+pub const TESTNET_EXPLORER_URL: &str = "https://app-testnet.fuel.network";
+pub const MAINNET_EXPLORER_URL: &str = "https://app.fuel.network";
+
+/// Default PrivateKey to sign transactions submitted to local node.
+pub const DEFAULT_PRIVATE_KEY: &str =
+    "0xde97d8624a438121b86a1956544bd72ed68cd69f2c99555b08b1e8c51ffd511c";
+/// The maximum time to wait for a transaction to be included in a block by the node
+pub const TX_SUBMIT_TIMEOUT_MS: u64 = 30_000u64;
diff --git a/forc-plugins/forc-client/src/lib.rs b/forc-plugins/forc-client/src/lib.rs
index 0c8cb335f5f..a4db6b262a1 100644
--- a/forc-plugins/forc-client/src/lib.rs
+++ b/forc-plugins/forc-client/src/lib.rs
@@ -1,7 +1,7 @@
 pub mod cmd;
-mod constants;
+pub mod constants;
 pub mod op;
-mod util;
+pub mod util;
 
 use clap::Parser;
 use serde::{Deserialize, Serialize};
@@ -14,19 +14,27 @@ pub struct NodeTarget {
     /// If unspecified, checks the manifest's `network` table, then falls back
     /// to `http://127.0.0.1:4000`
     ///
-    /// You can also use `--target` or `--testnet` to specify the Fuel node.
+    /// You can also use `--target`, `--testnet`, or `--mainnet` to specify the Fuel node.
     #[clap(long, env = "FUEL_NODE_URL")]
     pub node_url: Option<String>,
+
     /// Use preset configurations for deploying to a specific target.
     ///
-    /// You can also use `--node-url` or `--testnet` to specify the Fuel node.
+    /// You can also use `--node-url`, `--testnet`, or `--mainnet` to specify the Fuel node.
     ///
-    /// Possible values are: [beta-1, beta-2, beta-3, beta-4, local]
+    /// Possible values are: [local, testnet, mainnet]
     #[clap(long)]
     pub target: Option<Target>,
-    /// Use preset configuration for the latest testnet.
+
+    /// Use preset configuration for testnet.
     ///
-    /// You can also use `--node-url` or `--target` to specify the Fuel node.
+    /// You can also use `--node-url`, `--target`, or `--mainnet` to specify the Fuel node.
     #[clap(long)]
     pub testnet: bool,
+
+    /// Use preset configuration for mainnet.
+    ///
+    /// You can also use `--node-url`, `--target`, or `--testnet` to specify the Fuel node.
+    #[clap(long)]
+    pub mainnet: bool,
 }
diff --git a/forc-plugins/forc-client/src/op/deploy.rs b/forc-plugins/forc-client/src/op/deploy.rs
index e0270fa5245..cdc5d35162c 100644
--- a/forc-plugins/forc-client/src/op/deploy.rs
+++ b/forc-plugins/forc-client/src/op/deploy.rs
@@ -1,38 +1,83 @@
 use crate::{
     cmd,
+    constants::TX_SUBMIT_TIMEOUT_MS,
     util::{
-        gas::get_estimated_max_fee,
+        account::ForcClientAccount,
         node_url::get_node_url,
-        pkg::built_pkgs,
-        tx::{TransactionBuilderExt, WalletSelectionMode, TX_SUBMIT_TIMEOUT_MS},
+        pkg::{built_pkgs, create_proxy_contract, update_proxy_address_in_manifest},
+        target::Target,
+        tx::{
+            prompt_forc_wallet_password, select_account, update_proxy_contract_target,
+            SignerSelectionMode,
+        },
     },
 };
 use anyhow::{bail, Context, Result};
-use forc_pkg::manifest::GenericManifestFile;
 use forc_pkg::{self as pkg, PackageManifestFile};
-use forc_tracing::println_warning;
+use forc_pkg::{manifest::GenericManifestFile, MemberFilter};
+use forc_tracing::{println_action_green, println_warning};
 use forc_util::default_output_directory;
-use fuel_core_client::client::types::TransactionStatus;
+use forc_wallet::utils::default_wallet_path;
+use fuel_abi_types::abi::program::Configurable;
+use fuel_core_client::client::types::{ChainInfo, TransactionStatus};
 use fuel_core_client::client::FuelClient;
 use fuel_crypto::fuel_types::ChainId;
-use fuel_tx::{Output, Salt, TransactionBuilder};
-use fuel_vm::prelude::*;
-use fuels_accounts::provider::Provider;
+use fuel_tx::{Salt, Transaction};
+use fuel_vm::{consts::WORD_SIZE, fuel_asm::op, prelude::*};
+use fuels::{
+    macros::abigen,
+    programs::{
+        contract::{LoadConfiguration, StorageConfiguration},
+        executable::Executable,
+    },
+    types::{
+        bech32::Bech32ContractId,
+        transaction_builders::{Blob, BlobId},
+    },
+};
+use fuels_accounts::{provider::Provider, Account, ViewOnlyAccount};
+use fuels_core::types::{transaction::TxPolicies, transaction_builders::CreateTransactionBuilder};
 use futures::FutureExt;
 use pkg::{manifest::build_profile::ExperimentalFlags, BuildProfile, BuiltPackage};
 use serde::{Deserialize, Serialize};
-use std::time::Duration;
 use std::{
     collections::BTreeMap,
     path::{Path, PathBuf},
+    str::FromStr,
+    sync::Arc,
+    time::Duration,
 };
-use sway_core::language::parsed::TreeType;
 use sway_core::BuildTarget;
-use tracing::info;
+use sway_core::{asm_generation::ProgramABI, language::parsed::TreeType};
+
+/// Default maximum contract size allowed for a single contract. If the target
+/// contract size is bigger than this amount, forc-deploy will automatically
+/// starts dividing the contract and deploy them in chunks automatically.
+/// The value is in bytes
+const MAX_CONTRACT_SIZE: usize = 100_000;
+
+/// Represents a deployed instance of a forc package.
+/// Packages other than libraries are deployable through different mechanisms.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum DeployedPackage {
+    Contract(DeployedContract),
+    Script(DeployedExecutable),
+    Predicate(DeployedExecutable),
+}
 
-#[derive(Debug)]
+/// Represents a deployed contract on the Fuel network.
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd, Ord)]
 pub struct DeployedContract {
     pub id: fuel_tx::ContractId,
+    pub proxy: Option<fuel_tx::ContractId>,
+    pub chunked: bool,
+}
+
+/// Represents a deployed executable (script or predicate) on the Fuel network.
+/// Executables are deployed as blobs with generated loaders for efficiency.
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd, Ord)]
+pub struct DeployedExecutable {
+    pub bytecode: Vec<u8>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -43,7 +88,7 @@ pub struct DeploymentArtifact {
     chain_id: ChainId,
     contract_id: String,
     deployment_size: usize,
-    deployed_block_height: u32,
+    deployed_block_height: Option<u32>,
 }
 
 impl DeploymentArtifact {
@@ -113,39 +158,424 @@ fn validate_and_parse_salts<'a>(
     Ok(contract_salt_map)
 }
 
-/// Builds and deploys contract(s). If the given path corresponds to a workspace, all deployable members
-/// will be built and deployed.
+/// Depending on the cli options user passed, either returns storage slots from
+/// compiled package, or the ones user provided as overrides.
+fn resolve_storage_slots(
+    command: &cmd::Deploy,
+    compiled: &BuiltPackage,
+) -> Result<Vec<fuel_tx::StorageSlot>> {
+    let mut storage_slots =
+        if let Some(storage_slot_override_file) = &command.override_storage_slots {
+            let storage_slots_file = std::fs::read_to_string(storage_slot_override_file)?;
+            let storage_slots: Vec<StorageSlot> = serde_json::from_str(&storage_slots_file)?;
+            storage_slots
+        } else {
+            compiled.storage_slots.clone()
+        };
+    storage_slots.sort();
+    Ok(storage_slots)
+}
+
+/// Creates blobs from the contract to deploy contracts that are larger than
+/// maximum contract size. Created blobs are deployed, and a loader contract is
+/// generated such that it loads all the deployed blobs, and provides the user
+/// a single contract (loader contract that loads the blobs) to call into.
+async fn deploy_chunked(
+    command: &cmd::Deploy,
+    compiled: &BuiltPackage,
+    salt: Salt,
+    account: &ForcClientAccount,
+    provider: &Provider,
+    pkg_name: &str,
+) -> anyhow::Result<ContractId> {
+    println_action_green("Deploying", &format!("contract {pkg_name} chunks"));
+
+    let storage_slots = resolve_storage_slots(command, compiled)?;
+    let chain_info = provider.chain_info().await?;
+    let target = Target::from_str(&chain_info.name).unwrap_or_default();
+    let contract_url = match target.explorer_url() {
+        Some(explorer_url) => format!("{explorer_url}/contract/0x"),
+        None => "".to_string(),
+    };
+
+    let blobs = compiled
+        .bytecode
+        .bytes
+        .chunks(MAX_CONTRACT_SIZE)
+        .map(|chunk| Blob::new(chunk.to_vec()))
+        .collect();
+
+    let tx_policies = tx_policies_from_cmd(command);
+    let contract_id =
+        fuels::programs::contract::Contract::loader_from_blobs(blobs, salt, storage_slots)?
+            .deploy(account, tx_policies)
+            .await?
+            .into();
+
+    println_action_green(
+        "Finished",
+        &format!("deploying loader contract for {pkg_name} {contract_url}{contract_id}"),
+    );
+
+    Ok(contract_id)
+}
+
+/// Deploys a new proxy contract for the given package.
+async fn deploy_new_proxy(
+    command: &cmd::Deploy,
+    pkg_name: &str,
+    pkg_storage_slots: &[StorageSlot],
+    impl_contract: &fuel_tx::ContractId,
+    provider: &Provider,
+    account: &ForcClientAccount,
+) -> Result<ContractId> {
+    abigen!(Contract(name = "ProxyContract", abi = "{\"programType\":\"contract\",\"specVersion\":\"1\",\"encodingVersion\":\"1\",\"concreteTypes\":[{\"type\":\"()\",\"concreteTypeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"type\":\"enum standards::src5::AccessError\",\"concreteTypeId\":\"3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d\",\"metadataTypeId\":1},{\"type\":\"enum standards::src5::State\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"metadataTypeId\":2},{\"type\":\"enum std::option::Option<struct std::contract_id::ContractId>\",\"concreteTypeId\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"metadataTypeId\":4,\"typeArguments\":[\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\"]},{\"type\":\"enum sway_libs::ownership::errors::InitializationError\",\"concreteTypeId\":\"1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893\",\"metadataTypeId\":5},{\"type\":\"enum sway_libs::upgradability::errors::SetProxyOwnerError\",\"concreteTypeId\":\"3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74\",\"metadataTypeId\":6},{\"type\":\"str\",\"concreteTypeId\":\"8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a\"},{\"type\":\"struct std::contract_id::ContractId\",\"concreteTypeId\":\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\",\"metadataTypeId\":9},{\"type\":\"struct sway_libs::upgradability::events::ProxyOwnerSet\",\"concreteTypeId\":\"96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247\",\"metadataTypeId\":10},{\"type\":\"struct sway_libs::upgradability::events::ProxyTargetSet\",\"concreteTypeId\":\"1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8\",\"metadataTypeId\":11}],\"metadataTypes\":[{\"type\":\"b256\",\"metadataTypeId\":0},{\"type\":\"enum standards::src5::AccessError\",\"metadataTypeId\":1,\"components\":[{\"name\":\"NotOwner\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum standards::src5::State\",\"metadataTypeId\":2,\"components\":[{\"name\":\"Uninitialized\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"name\":\"Initialized\",\"typeId\":3},{\"name\":\"Revoked\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum std::identity::Identity\",\"metadataTypeId\":3,\"components\":[{\"name\":\"Address\",\"typeId\":8},{\"name\":\"ContractId\",\"typeId\":9}]},{\"type\":\"enum std::option::Option\",\"metadataTypeId\":4,\"components\":[{\"name\":\"None\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"name\":\"Some\",\"typeId\":7}],\"typeParameters\":[7]},{\"type\":\"enum sway_libs::ownership::errors::InitializationError\",\"metadataTypeId\":5,\"components\":[{\"name\":\"CannotReinitialized\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum sway_libs::upgradability::errors::SetProxyOwnerError\",\"metadataTypeId\":6,\"components\":[{\"name\":\"CannotUninitialize\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"generic T\",\"metadataTypeId\":7},{\"type\":\"struct std::address::Address\",\"metadataTypeId\":8,\"components\":[{\"name\":\"bits\",\"typeId\":0}]},{\"type\":\"struct std::contract_id::ContractId\",\"metadataTypeId\":9,\"components\":[{\"name\":\"bits\",\"typeId\":0}]},{\"type\":\"struct sway_libs::upgradability::events::ProxyOwnerSet\",\"metadataTypeId\":10,\"components\":[{\"name\":\"new_proxy_owner\",\"typeId\":2}]},{\"type\":\"struct sway_libs::upgradability::events::ProxyTargetSet\",\"metadataTypeId\":11,\"components\":[{\"name\":\"new_target\",\"typeId\":9}]}],\"functions\":[{\"inputs\":[],\"name\":\"proxy_target\",\"output\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Returns the target contract of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Returns\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * [Option<ContractId>] - The new proxy contract to which all fallback calls will be passed or `None`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\"]}]},{\"inputs\":[{\"name\":\"new_target\",\"concreteTypeId\":\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\"}],\"name\":\"set_proxy_target\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Change the target contract of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can only be called by the `proxy_owner`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Arguments\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * `new_target`: [ContractId] - The new proxy contract to which all fallback calls will be passed.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When not called by `proxy_owner`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Write: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\",\"write\"]}]},{\"inputs\":[],\"name\":\"proxy_owner\",\"output\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Returns the owner of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Returns\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * [State] - Represents the state of ownership for this contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\"]}]},{\"inputs\":[],\"name\":\"initialize_proxy\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Initializes the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method sets the storage values using the values of the configurable constants `INITIAL_TARGET` and `INITIAL_OWNER`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This then allows methods that write to storage to be called.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can only be called once.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When `storage::SRC14.proxy_owner` is not [State::Uninitialized].\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Writes: `2`\"]},{\"name\":\"storage\",\"arguments\":[\"write\"]}]},{\"inputs\":[{\"name\":\"new_proxy_owner\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\"}],\"name\":\"set_proxy_owner\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Changes proxy ownership to the passed State.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can be used to transfer ownership between Identities or to revoke ownership.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Arguments\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * `new_proxy_owner`: [State] - The new state of the proxy ownership.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When the sender is not the current proxy owner.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When the new state of the proxy ownership is [State::Uninitialized].\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Writes: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"write\"]}]}],\"loggedTypes\":[{\"logId\":\"4571204900286667806\",\"concreteTypeId\":\"3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d\"},{\"logId\":\"2151606668983994881\",\"concreteTypeId\":\"1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8\"},{\"logId\":\"2161305517876418151\",\"concreteTypeId\":\"1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893\"},{\"logId\":\"4354576968059844266\",\"concreteTypeId\":\"3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74\"},{\"logId\":\"10870989709723147660\",\"concreteTypeId\":\"96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247\"},{\"logId\":\"10098701174489624218\",\"concreteTypeId\":\"8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a\"}],\"messagesTypes\":[],\"configurables\":[{\"name\":\"INITIAL_TARGET\",\"concreteTypeId\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"offset\":13368},{\"name\":\"INITIAL_OWNER\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"offset\":13320}]}",));
+    let proxy_dir_output = create_proxy_contract(pkg_name)?;
+    let address = account.address();
+
+    // Add the combined storage slots from the original contract and the proxy contract.
+    let proxy_storage_path = proxy_dir_output.join("proxy-storage_slots.json");
+    let storage_configuration = StorageConfiguration::default()
+        .add_slot_overrides(pkg_storage_slots.iter().cloned())
+        .add_slot_overrides_from_file(proxy_storage_path)?;
+
+    let configurables = ProxyContractConfigurables::default()
+        .with_INITIAL_TARGET(Some(*impl_contract))?
+        .with_INITIAL_OWNER(State::Initialized(Address::from(address).into()))?;
+
+    let configuration = LoadConfiguration::default()
+        .with_storage_configuration(storage_configuration)
+        .with_configurables(configurables);
+
+    let tx_policies = tx_policies_from_cmd(command);
+    let proxy_contract_id: ContractId = fuels::programs::contract::Contract::load_from(
+        proxy_dir_output.join("proxy.bin"),
+        configuration,
+    )?
+    .deploy(account, tx_policies)
+    .await?
+    .into();
+
+    let chain_info = provider.chain_info().await?;
+    let target = Target::from_str(&chain_info.name).unwrap_or_default();
+    let contract_url = match target.explorer_url() {
+        Some(explorer_url) => format!("{explorer_url}/contract/0x"),
+        None => "".to_string(),
+    };
+
+    println_action_green(
+        "Finished",
+        &format!("deploying proxy contract for {pkg_name} {contract_url}{proxy_contract_id}"),
+    );
+
+    let proxy_contract_bech_id: Bech32ContractId = proxy_contract_id.into();
+    let instance = ProxyContract::new(&proxy_contract_bech_id, account.clone());
+    instance.methods().initialize_proxy().call().await?;
+    println_action_green("Initialized", &format!("proxy contract for {pkg_name}"));
+    Ok(proxy_contract_id)
+}
+
+/// Builds and deploys contracts, scripts, and predicates from the given path or workspace.
 ///
-/// Upon success, returns the ID of each deployed contract in order of deployment.
+/// Contracts are deployed directly, while scripts and predicates are deployed as blobs with generated loaders.
 ///
-/// When deploying a single contract, only that contract's ID is returned.
-pub async fn deploy(command: cmd::Deploy) -> Result<Vec<DeployedContract>> {
+/// Returns a vector of `DeployedPackage` representing all successful deployments.
+pub async fn deploy(command: cmd::Deploy) -> Result<Vec<DeployedPackage>> {
     if command.unsigned {
         println_warning("--unsigned flag is deprecated, please prefer using --default-signer. Assuming `--default-signer` is passed. This means your transaction will be signed by an account that is funded by fuel-core by default for testing purposes.");
     }
-
-    let mut contract_ids = Vec::new();
     let curr_dir = if let Some(ref path) = command.pkg.path {
         PathBuf::from(path)
     } else {
         std::env::current_dir()?
     };
-
-    let build_opts = build_opts_from_cmd(&command);
+    let build_opts = build_opts_from_cmd(&command, MemberFilter::default());
     let built_pkgs = built_pkgs(&curr_dir, &build_opts)?;
+    let mut deployed_packages = Vec::new();
+
+    let contracts_to_deploy = built_pkgs
+        .iter()
+        .filter(|pkg| {
+            pkg.descriptor
+                .manifest_file
+                .check_program_type(&[TreeType::Contract])
+                .is_ok()
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+
+    let scripts_to_deploy = built_pkgs
+        .iter()
+        .filter(|pkg| {
+            pkg.descriptor
+                .manifest_file
+                .check_program_type(&[TreeType::Script])
+                .is_ok()
+        })
+        .cloned()
+        .collect::<Vec<_>>();
 
-    if built_pkgs.is_empty() {
-        println_warning("No deployable contracts found in the current directory.");
-        return Ok(contract_ids);
+    let predicates_to_deploy = built_pkgs
+        .iter()
+        .filter(|pkg| {
+            pkg.descriptor
+                .manifest_file
+                .check_program_type(&[TreeType::Predicate])
+                .is_ok()
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+
+    if contracts_to_deploy.is_empty()
+        && scripts_to_deploy.is_empty()
+        && predicates_to_deploy.is_empty()
+    {
+        println_warning("No deployable package was found in the current directory.");
+    } else {
+        deployed_packages.extend(
+            deploy_contracts(&command, &contracts_to_deploy)
+                .await?
+                .into_iter()
+                .map(DeployedPackage::Contract),
+        );
+        deployed_packages.extend(
+            deploy_executables(&command, &scripts_to_deploy)
+                .await?
+                .into_iter()
+                .map(DeployedPackage::Script),
+        );
+        deployed_packages.extend(
+            deploy_executables(&command, &predicates_to_deploy)
+                .await?
+                .into_iter()
+                .map(DeployedPackage::Predicate),
+        );
+    }
+
+    Ok(deployed_packages)
+}
+
+/// Calculates the loader data offset. Returns a `None` if the original `binary`
+/// does not have a data section (no configurables and no args). Otherwise
+/// returns the new offset of the data section.
+fn loader_data_offset(binary: &[u8], blob_id: &BlobId) -> Result<Option<usize>> {
+    // The following code is taken from SDK, and once they expose the offsets
+    // we will no longer need to maintain this duplicate version here.
+
+    // The final code is going to have this structure (if the data section is non-empty):
+    // 1. loader instructions
+    // 2. blob id
+    // 3. length_of_data_section
+    // 4. the data_section (updated with configurables as needed)
+    const BLOB_ID_SIZE: u16 = 32;
+    const REG_ADDRESS_OF_DATA_AFTER_CODE: u8 = 0x10;
+    const REG_START_OF_LOADED_CODE: u8 = 0x11;
+    const REG_GENERAL_USE: u8 = 0x12;
+    let get_instructions = |num_of_instructions| {
+        // There are 3 main steps:
+        // 1. Load the blob content into memory
+        // 2. Load the data section right after the blob
+        // 3. Jump to the beginning of the memory where the blob was loaded
+        [
+            // 1. Load the blob content into memory
+            // Find the start of the hardcoded blob ID, which is located after the loader code ends.
+            op::move_(REG_ADDRESS_OF_DATA_AFTER_CODE, RegId::PC),
+            // hold the address of the blob ID.
+            op::addi(
+                REG_ADDRESS_OF_DATA_AFTER_CODE,
+                REG_ADDRESS_OF_DATA_AFTER_CODE,
+                num_of_instructions * Instruction::SIZE as u16,
+            ),
+            // The code is going to be loaded from the current value of SP onwards, save
+            // the location into REG_START_OF_LOADED_CODE so we can jump into it at the end.
+            op::move_(REG_START_OF_LOADED_CODE, RegId::SP),
+            // REG_GENERAL_USE to hold the size of the blob.
+            op::bsiz(REG_GENERAL_USE, REG_ADDRESS_OF_DATA_AFTER_CODE),
+            // Push the blob contents onto the stack.
+            op::ldc(REG_ADDRESS_OF_DATA_AFTER_CODE, 0, REG_GENERAL_USE, 1),
+            // Move on to the data section length
+            op::addi(
+                REG_ADDRESS_OF_DATA_AFTER_CODE,
+                REG_ADDRESS_OF_DATA_AFTER_CODE,
+                BLOB_ID_SIZE,
+            ),
+            // load the size of the data section into REG_GENERAL_USE
+            op::lw(REG_GENERAL_USE, REG_ADDRESS_OF_DATA_AFTER_CODE, 0),
+            // after we have read the length of the data section, we move the pointer to the actual
+            // data by skipping WORD_SIZE B.
+            op::addi(
+                REG_ADDRESS_OF_DATA_AFTER_CODE,
+                REG_ADDRESS_OF_DATA_AFTER_CODE,
+                WORD_SIZE as u16,
+            ),
+            // load the data section of the executable
+            op::ldc(REG_ADDRESS_OF_DATA_AFTER_CODE, 0, REG_GENERAL_USE, 2),
+            // Jump into the memory where the contract is loaded.
+            // What follows is called _jmp_mem by the sway compiler.
+            // Subtract the address contained in IS because jmp will add it back.
+            op::sub(
+                REG_START_OF_LOADED_CODE,
+                REG_START_OF_LOADED_CODE,
+                RegId::IS,
+            ),
+            // jmp will multiply by 4, so we need to divide to cancel that out.
+            op::divi(REG_START_OF_LOADED_CODE, REG_START_OF_LOADED_CODE, 4),
+            // Jump to the start of the contract we loaded.
+            op::jmp(REG_START_OF_LOADED_CODE),
+        ]
+    };
+
+    let offset = extract_data_offset(binary)?;
+
+    if binary.len() < offset {
+        anyhow::bail!("data sectio offset is out of bounds");
+    }
+
+    let data_section = binary[offset..].to_vec();
+
+    if !data_section.is_empty() {
+        let num_of_instructions = u16::try_from(get_instructions(0).len())
+            .expect("to never have more than u16::MAX instructions");
+
+        let instruction_bytes = get_instructions(num_of_instructions)
+            .into_iter()
+            .flat_map(|instruction| instruction.to_bytes());
+
+        let blob_bytes = blob_id.iter().copied();
+
+        let loader_offset =
+            instruction_bytes.count() + blob_bytes.count() + data_section.len().to_be_bytes().len();
+
+        Ok(Some(loader_offset))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Builds and deploys executable (script and predicate) package(s) as blobs,
+/// and generates a loader for each of them.
+pub async fn deploy_executables(
+    command: &cmd::Deploy,
+    executables_to_deploy: &[Arc<BuiltPackage>],
+) -> Result<Vec<DeployedExecutable>> {
+    let mut deployed_executable = vec![];
+    if executables_to_deploy.is_empty() {
+        return Ok(deployed_executable);
+    }
+
+    let node_url = validate_and_get_node_url(command, executables_to_deploy).await?;
+    // We will have 1 transaction per executable as each deployment uses a single blob.
+    let tx_count = executables_to_deploy.len();
+    let account = setup_deployment_account(command, &node_url, tx_count).await?;
+
+    for pkg in executables_to_deploy {
+        let script = Executable::from_bytes(pkg.bytecode.bytes.clone());
+        let loader = script.convert_to_loader()?;
+        println_action_green("Uploading", "blob containing executable bytecode.");
+        loader.upload_blob(account.clone()).await?;
+        println_action_green("Generating", "loader bytecode for the uploaded executable.");
+        let loader_bytecode = loader.code();
+        let pkg_name = &pkg.descriptor.name;
+        let out_dir = pkg.descriptor.manifest_file.dir().join("out");
+        let bin_path = out_dir.join(format!("{pkg_name}-loader.bin"));
+        std::fs::write(&bin_path, &loader_bytecode)?;
+        println_action_green(
+            "Saved",
+            &format!("loader bytecode at {}", bin_path.display()),
+        );
+        if let Some(loader_data_section_offset) =
+            loader_data_offset(&pkg.bytecode.bytes, &BlobId::default())?
+        {
+            if let ProgramABI::Fuel(mut fuel_abi) = pkg.program_abi.clone() {
+                println_action_green("Generating", "loader abi for the uploaded executable.");
+                let json_abi_path = out_dir.join(format!("{pkg_name}-loader-abi.json"));
+                let original_data_section = extract_data_offset(&pkg.bytecode.bytes).unwrap();
+                let offset_shift = original_data_section - loader_data_section_offset;
+                // if there are configurables in the abi we need to shift them by `offset_shift`.
+                let configurables = fuel_abi.configurables.clone().map(|configs| {
+                    configs
+                        .into_iter()
+                        .map(|config| Configurable {
+                            offset: config.offset - offset_shift as u64,
+                            ..config.clone()
+                        })
+                        .collect()
+                });
+                fuel_abi.configurables = configurables;
+                let json_string = serde_json::to_string_pretty(&fuel_abi)?;
+                std::fs::write(json_abi_path, json_string)?;
+            }
+        }
+        // If the executable is a predicate, we also want to display and save the predicate root.
+        if pkg
+            .descriptor
+            .manifest_file
+            .program_type()
+            .with_context(|| {
+                "error while trying to retrieve program type for executable deployment."
+            })?
+            == TreeType::Predicate
+        {
+            // Calculate the root.
+            let root = format!("0x{}", fuel_tx::Input::predicate_owner(&loader_bytecode));
+            // Root files are named in `pkg-name-root` format, since this is a
+            // loader we are also adding an identifier to differentiate it from
+            // the root of the "original" predicate.
+            let root_file_name = format!("{}-loader-root", &pkg_name);
+            let root_path = out_dir.join(root_file_name);
+            std::fs::write(&root_path, &root)?;
+            println_action_green(
+                "Saved",
+                &format!("loader root ({}) at {}", root, root_path.display()),
+            );
+        }
+        let deployed = DeployedExecutable {
+            bytecode: loader_bytecode,
+        };
+        deployed_executable.push(deployed);
+        println_action_green("Finished", &format!("deploying executable {pkg_name}"));
+    }
+    Ok(deployed_executable)
+}
+
+fn extract_data_offset(binary: &[u8]) -> Result<usize> {
+    if binary.len() < 16 {
+        anyhow::bail!(
+            "given binary is too short to contain a data offset, len: {}",
+            binary.len()
+        );
+    }
+
+    let data_offset: [u8; 8] = binary[8..16].try_into().expect("checked above");
+
+    Ok(u64::from_be_bytes(data_offset) as usize)
+}
+
+/// Builds and deploys contract(s). If the given path corresponds to a workspace, all deployable members
+/// will be built and deployed.
+///
+/// Upon success, returns the ID of each deployed contract in order of deployment.
+///
+/// When deploying a single contract, only that contract's ID is returned.
+pub async fn deploy_contracts(
+    command: &cmd::Deploy,
+    contracts_to_deploy: &[Arc<BuiltPackage>],
+) -> Result<Vec<DeployedContract>> {
+    let mut deployed_contracts = Vec::new();
+
+    if contracts_to_deploy.is_empty() {
+        return Ok(deployed_contracts);
     }
 
     let contract_salt_map = if let Some(salt_input) = &command.salt {
         // If we're building 1 package, we just parse the salt as a string, ie. 0x00...
         // If we're building >1 package, we must parse the salt as a pair of strings, ie. contract_name:0x00...
-        if built_pkgs.len() > 1 {
+        if contracts_to_deploy.len() > 1 {
             let map = validate_and_parse_salts(
                 salt_input,
-                built_pkgs.iter().map(|b| &b.descriptor.manifest_file),
+                contracts_to_deploy
+                    .iter()
+                    .map(|b| &b.descriptor.manifest_file),
             )?;
 
             Some(map)
@@ -163,7 +593,7 @@ pub async fn deploy(command: cmd::Deploy) -> Result<Vec<DeployedContract>> {
                 .unwrap();
             let mut contract_salt_map = ContractSaltMap::default();
             contract_salt_map.insert(
-                built_pkgs[0]
+                contracts_to_deploy[0]
                     .descriptor
                     .manifest_file
                     .project_name()
@@ -176,167 +606,294 @@ pub async fn deploy(command: cmd::Deploy) -> Result<Vec<DeployedContract>> {
         None
     };
 
-    for pkg in built_pkgs {
-        if pkg
-            .descriptor
-            .manifest_file
-            .check_program_type(&[TreeType::Contract])
-            .is_ok()
-        {
-            let salt = match (&contract_salt_map, command.default_salt) {
-                (Some(map), false) => {
-                    if let Some(salt) = map.get(pkg.descriptor.manifest_file.project_name()) {
-                        *salt
+    let node_url = validate_and_get_node_url(command, contracts_to_deploy).await?;
+    let provider = Provider::connect(node_url.clone()).await?;
+
+    // Confirmation step. Summarize the transaction(s) for the deployment.
+    let account = confirm_transaction_details(
+        contracts_to_deploy,
+        command,
+        node_url.clone(),
+        MAX_CONTRACT_SIZE,
+    )
+    .await?;
+
+    for pkg in contracts_to_deploy {
+        let salt = match (&contract_salt_map, command.default_salt) {
+            (Some(map), false) => {
+                if let Some(salt) = map.get(pkg.descriptor.manifest_file.project_name()) {
+                    *salt
+                } else {
+                    Default::default()
+                }
+            }
+            (None, true) => Default::default(),
+            (None, false) => rand::random(),
+            (Some(_), true) => {
+                bail!("Both `--salt` and `--default-salt` were specified: must choose one")
+            }
+        };
+        let bytecode_size = pkg.bytecode.bytes.len();
+        let deployed_contract_id = if bytecode_size > MAX_CONTRACT_SIZE {
+            // Deploy chunked
+            let node_url = get_node_url(&command.node, &pkg.descriptor.manifest_file.network)?;
+            let provider = Provider::connect(node_url).await?;
+
+            deploy_chunked(
+                command,
+                pkg,
+                salt,
+                &account,
+                &provider,
+                &pkg.descriptor.name,
+            )
+            .await?
+        } else {
+            deploy_pkg(command, pkg, salt, &provider, &account).await?
+        };
+
+        let proxy_id = match &pkg.descriptor.manifest_file.proxy {
+            Some(forc_pkg::manifest::Proxy {
+                enabled: true,
+                address: Some(proxy_addr),
+            }) => {
+                // Make a call into the contract to update impl contract address to 'deployed_contract'.
+
+                // Create a contract instance for the proxy contract using default proxy contract abi and
+                // specified address.
+                let proxy_contract =
+                    ContractId::from_str(proxy_addr).map_err(|e| anyhow::anyhow!(e))?;
+
+                update_proxy_contract_target(&account, proxy_contract, deployed_contract_id)
+                    .await?;
+                Some(proxy_contract)
+            }
+            Some(forc_pkg::manifest::Proxy {
+                enabled: true,
+                address: None,
+            }) => {
+                let pkg_name = &pkg.descriptor.name;
+                let pkg_storage_slots = &pkg.storage_slots;
+                // Deploy a new proxy contract.
+                let deployed_proxy_contract = deploy_new_proxy(
+                    command,
+                    pkg_name,
+                    pkg_storage_slots,
+                    &deployed_contract_id,
+                    &provider,
+                    &account,
+                )
+                .await?;
+
+                // Update manifest file such that the proxy address field points to the new proxy contract.
+                update_proxy_address_in_manifest(
+                    &format!("0x{}", deployed_proxy_contract),
+                    &pkg.descriptor.manifest_file,
+                )?;
+                Some(deployed_proxy_contract)
+            }
+            // Proxy not enabled.
+            _ => None,
+        };
+
+        let deployed_contract = DeployedContract {
+            id: deployed_contract_id,
+            proxy: proxy_id,
+            chunked: bytecode_size > MAX_CONTRACT_SIZE,
+        };
+        deployed_contracts.push(deployed_contract);
+    }
+    Ok(deployed_contracts)
+}
+
+/// Prompt the user to confirm the transactions required for deployment, as well as the signing key.
+async fn confirm_transaction_details(
+    pkgs_to_deploy: &[Arc<BuiltPackage>],
+    command: &cmd::Deploy,
+    node_url: String,
+    max_contract_size: usize,
+) -> Result<ForcClientAccount> {
+    // Confirmation step. Summarize the transaction(s) for the deployment.
+    let mut tx_count = 0;
+    let tx_summary = pkgs_to_deploy
+        .iter()
+        .map(|pkg| {
+            tx_count += 1;
+            let proxy_text = match &pkg.descriptor.manifest_file.proxy {
+                Some(forc_pkg::manifest::Proxy {
+                    enabled: true,
+                    address,
+                }) => {
+                    tx_count += 1;
+                    if address.is_some() {
+                        " + update proxy"
                     } else {
-                        Default::default()
+                        " + deploy proxy"
                     }
                 }
-                (None, true) => Default::default(),
-                (None, false) => rand::random(),
-                (Some(_), true) => {
-                    bail!("Both `--salt` and `--default-salt` were specified: must choose one")
-                }
+                _ => "",
             };
-            let contract_id =
-                deploy_pkg(&command, &pkg.descriptor.manifest_file, &pkg, salt).await?;
-            contract_ids.push(contract_id);
-        }
-    }
-    Ok(contract_ids)
+
+            let pkg_bytecode_len = pkg.bytecode.bytes.len();
+            let blob_text = if pkg_bytecode_len > max_contract_size {
+                let number_of_blobs = pkg_bytecode_len.div_ceil(max_contract_size);
+                tx_count += number_of_blobs;
+                &format!(" + {number_of_blobs} blobs")
+            } else {
+                ""
+            };
+
+            format!(
+                "deploy {}{blob_text}{proxy_text}",
+                pkg.descriptor.manifest_file.project_name()
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(" + ");
+
+    println_action_green("Confirming", &format!("transactions [{tx_summary}]"));
+    println_action_green("", &format!("Network: {node_url}"));
+
+    let account = setup_deployment_account(command, &node_url, tx_count).await?;
+
+    // TODO: Display the estimated gas cost of the transaction(s).
+    // https://github.com/FuelLabs/sway/issues/6277
+
+    Ok(account)
 }
 
 /// Deploy a single pkg given deploy command and the manifest file
 pub async fn deploy_pkg(
     command: &cmd::Deploy,
-    manifest: &PackageManifestFile,
     compiled: &BuiltPackage,
     salt: Salt,
-) -> Result<DeployedContract> {
-    let node_url = get_node_url(&command.node, &manifest.network)?;
-    let client = FuelClient::new(node_url.clone())?;
+    provider: &Provider,
+    account: &ForcClientAccount,
+) -> Result<fuel_tx::ContractId> {
+    let manifest = &compiled.descriptor.manifest_file;
+    let node_url = provider.url();
+    let client = FuelClient::new(node_url)?;
 
     let bytecode = &compiled.bytecode.bytes;
 
-    let mut storage_slots =
-        if let Some(storage_slot_override_file) = &command.override_storage_slots {
-            let storage_slots_file = std::fs::read_to_string(storage_slot_override_file)?;
-            let storage_slots: Vec<StorageSlot> = serde_json::from_str(&storage_slots_file)?;
-            storage_slots
-        } else {
-            compiled.storage_slots.clone()
-        };
-    storage_slots.sort();
-
+    let storage_slots = resolve_storage_slots(command, compiled)?;
     let contract = Contract::from(bytecode.clone());
     let root = contract.root();
     let state_root = Contract::initial_state_root(storage_slots.iter());
     let contract_id = contract.id(&salt, &root, &state_root);
+    let tx_policies = tx_policies_from_cmd(command);
 
-    let wallet_mode = if command.manual_signing {
-        WalletSelectionMode::Manual
-    } else {
-        WalletSelectionMode::ForcWallet
-    };
-
-    let provider = Provider::connect(node_url.clone()).await?;
+    let mut tb = CreateTransactionBuilder::prepare_contract_deployment(
+        bytecode.clone(),
+        contract_id,
+        state_root,
+        salt,
+        storage_slots.clone(),
+        tx_policies,
+    );
 
-    // We need a tx for estimation without the signature.
-    let mut tb =
-        TransactionBuilder::create(bytecode.as_slice().into(), salt, storage_slots.clone());
-    tb.maturity(command.maturity.maturity.into())
-        .add_output(Output::contract_created(contract_id, state_root));
-    let tx_for_estimation = tb.finalize_without_signature_inner();
+    account.add_witnesses(&mut tb)?;
+    account.adjust_for_fee(&mut tb, 0).await?;
 
-    // If user specified max_fee use that but if not, we will estimate with %10 safety margin.
-    let max_fee = if let Some(max_fee) = command.gas.max_fee {
-        max_fee
-    } else {
-        let estimation_margin = 10;
-        get_estimated_max_fee(
-            tx_for_estimation.clone(),
-            &provider,
-            &client,
-            estimation_margin,
-        )
-        .await?
-    };
-
-    let tx = tb
-        .max_fee_limit(max_fee)
-        .finalize_signed(
-            provider.clone(),
-            command.default_signer || command.unsigned,
-            command.signing_key,
-            wallet_mode,
-        )
-        .await?;
+    let tx = tb.build(provider).await?;
     let tx = Transaction::from(tx);
 
-    let chain_id = client.chain_info().await?.consensus_parameters.chain_id();
-
-    let deployment_request = client.submit_and_await_commit(&tx).map(|res| match res {
-        Ok(logs) => match logs {
-            TransactionStatus::Submitted { .. } => {
-                bail!("contract {} deployment timed out", &contract_id);
-            }
-            TransactionStatus::Success { block_height, .. } => {
-                let pkg_name = manifest.project_name();
-                info!("\n\nContract {pkg_name} Deployed!");
-
-                info!("\nNetwork: {node_url}");
-                info!("Contract ID: 0x{contract_id}");
-                info!("Deployed in block {}", &block_height);
+    let chain_info = client.chain_info().await?;
+    let chain_id = chain_info.consensus_parameters.chain_id();
 
+    // If only submitting the transaction, don't wait for the deployment to complete
+    let contract_id: ContractId = if command.submit_only {
+        match client.submit(&tx).await {
+            Ok(transaction_id) => {
                 // Create a deployment artifact.
-                let deployment_size = bytecode.len();
-                let deployment_artifact = DeploymentArtifact {
-                    transaction_id: format!("0x{}", tx.id(&chain_id)),
-                    salt: format!("0x{}", salt),
-                    network_endpoint: node_url.to_string(),
-                    chain_id,
-                    contract_id: format!("0x{}", contract_id),
-                    deployment_size,
-                    deployed_block_height: *block_height,
-                };
-
-                let output_dir = command
-                    .pkg
-                    .output_directory
-                    .as_ref()
-                    .map(PathBuf::from)
-                    .unwrap_or_else(|| default_output_directory(manifest.dir()))
-                    .join("deployments");
-                deployment_artifact.to_file(&output_dir, pkg_name, contract_id)?;
-
-                Ok(contract_id)
+                create_deployment_artifact(
+                    DeploymentArtifact {
+                        transaction_id: format!("0x{}", transaction_id),
+                        salt: format!("0x{}", salt),
+                        network_endpoint: node_url.to_string(),
+                        chain_id,
+                        contract_id: format!("0x{}", contract_id),
+                        deployment_size: bytecode.len(),
+                        deployed_block_height: None,
+                    },
+                    command,
+                    manifest,
+                    chain_info,
+                )?;
+
+                contract_id
             }
-            e => {
+            Err(e) => {
                 bail!(
                     "contract {} failed to deploy due to an error: {:?}",
                     &contract_id,
                     e
                 )
             }
-        },
-        Err(e) => bail!("{e}"),
-    });
+        }
+    } else {
+        let deployment_request = client.submit_and_await_commit(&tx).map(|res| match res {
+            Ok(logs) => match logs {
+                TransactionStatus::Submitted { .. } => {
+                    bail!("contract {} deployment timed out", &contract_id);
+                }
+                TransactionStatus::Success { block_height, .. } => {
+                    // Create a deployment artifact.
+                    create_deployment_artifact(
+                        DeploymentArtifact {
+                            transaction_id: format!("0x{}", tx.id(&chain_id)),
+                            salt: format!("0x{}", salt),
+                            network_endpoint: node_url.to_string(),
+                            chain_id,
+                            contract_id: format!("0x{}", contract_id),
+                            deployment_size: bytecode.len(),
+                            deployed_block_height: Some(*block_height),
+                        },
+                        command,
+                        manifest,
+                        chain_info,
+                    )?;
 
-    // submit contract deployment with a timeout
-    let contract_id = tokio::time::timeout(
-        Duration::from_millis(TX_SUBMIT_TIMEOUT_MS),
-        deployment_request,
-    )
-    .await
-    .with_context(|| {
-        format!(
-            "Timed out waiting for contract {} to deploy. The transaction may have been dropped.",
-            &contract_id
+                    Ok(contract_id)
+                }
+                e => {
+                    bail!(
+                        "contract {} failed to deploy due to an error: {:?}",
+                        &contract_id,
+                        e
+                    )
+                }
+            },
+            Err(e) => bail!("{e}"),
+        });
+        tokio::time::timeout(
+            Duration::from_millis(TX_SUBMIT_TIMEOUT_MS),
+            deployment_request,
         )
-    })??;
-    Ok(DeployedContract { id: contract_id })
+            .await
+            .with_context(|| {
+                format!(
+                    "Timed out waiting for contract {} to deploy. The transaction may have been dropped.",
+                    &contract_id
+                )
+            })??
+    };
+
+    Ok(contract_id)
 }
 
-fn build_opts_from_cmd(cmd: &cmd::Deploy) -> pkg::BuildOpts {
+fn tx_policies_from_cmd(cmd: &cmd::Deploy) -> TxPolicies {
+    let mut tx_policies = TxPolicies::default();
+    if let Some(max_fee) = cmd.gas.max_fee {
+        tx_policies = tx_policies.with_max_fee(max_fee);
+    }
+    if let Some(script_gas_limit) = cmd.gas.script_gas_limit {
+        tx_policies = tx_policies.with_script_gas_limit(script_gas_limit);
+    }
+    tx_policies
+}
+
+fn build_opts_from_cmd(cmd: &cmd::Deploy, member_filter: pkg::MemberFilter) -> pkg::BuildOpts {
     pkg::BuildOpts {
         pkg: pkg::PkgOpts {
             path: cmd.pkg.path.clone(),
@@ -344,7 +901,6 @@ fn build_opts_from_cmd(cmd: &cmd::Deploy) -> pkg::BuildOpts {
             terse: cmd.pkg.terse,
             locked: cmd.pkg.locked,
             output_directory: cmd.pkg.output_directory.clone(),
-            json_abi_with_callpaths: cmd.pkg.json_abi_with_callpaths,
             ipfs_node: cmd.pkg.ipfs_node.clone().unwrap_or_default(),
         },
         print: pkg::PrintOpts {
@@ -353,6 +909,7 @@ fn build_opts_from_cmd(cmd: &cmd::Deploy) -> pkg::BuildOpts {
             dca_graph_url_format: cmd.print.dca_graph_url_format.clone(),
             asm: cmd.print.asm(),
             bytecode: cmd.print.bytecode,
+            bytecode_spans: false,
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
@@ -369,13 +926,100 @@ fn build_opts_from_cmd(cmd: &cmd::Deploy) -> pkg::BuildOpts {
         debug_outfile: cmd.build_output.debug_file.clone(),
         build_target: BuildTarget::default(),
         tests: false,
-        member_filter: pkg::MemberFilter::only_contracts(),
+        member_filter,
         experimental: ExperimentalFlags {
             new_encoding: !cmd.no_encoding_v1,
         },
     }
 }
 
+/// Creates a deployment artifact and writes it to a file.
+///
+/// This function is used to generate a deployment artifact containing details
+/// about the deployment, such as the transaction ID, salt, network endpoint,
+/// chain ID, contract ID, deployment size, and deployed block height. It then
+/// writes this artifact to a specified output directory.
+fn create_deployment_artifact(
+    deployment_artifact: DeploymentArtifact,
+    cmd: &cmd::Deploy,
+    manifest: &PackageManifestFile,
+    chain_info: ChainInfo,
+) -> Result<()> {
+    let contract_id = ContractId::from_str(&deployment_artifact.contract_id).unwrap();
+    let pkg_name = manifest.project_name();
+
+    let target = Target::from_str(&chain_info.name).unwrap_or_default();
+    let (contract_url, block_url) = match target.explorer_url() {
+        Some(explorer_url) => (
+            format!("{explorer_url}/contract/0x"),
+            format!("{explorer_url}/block/"),
+        ),
+        None => ("".to_string(), "".to_string()),
+    };
+    println_action_green(
+        "Finished",
+        &format!("deploying {pkg_name} {contract_url}{contract_id}"),
+    );
+
+    let block_height = deployment_artifact.deployed_block_height;
+    if let Some(block_height) = block_height {
+        println_action_green("Deployed", &format!("in block {block_url}{block_height}"));
+    }
+
+    let output_dir = cmd
+        .pkg
+        .output_directory
+        .as_ref()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| default_output_directory(manifest.dir()))
+        .join("deployments");
+    deployment_artifact.to_file(&output_dir, pkg_name, contract_id)
+}
+
+/// Validates that all packages are being deployed to the same node and returns the node URL.
+async fn validate_and_get_node_url(
+    command: &cmd::Deploy,
+    packages: &[Arc<BuiltPackage>],
+) -> Result<String> {
+    let node_url = get_node_url(&command.node, &packages[0].descriptor.manifest_file.network)?;
+    if !packages.iter().all(|pkg| {
+        get_node_url(&command.node, &pkg.descriptor.manifest_file.network).ok()
+            == Some(node_url.clone())
+    }) {
+        bail!("All packages in a deployment should be deployed to the same node. Please ensure that the network specified in the Forc.toml files of all packages is the same.");
+    }
+    Ok(node_url)
+}
+
+/// Sets up and returns the account for deployment.
+async fn setup_deployment_account(
+    command: &cmd::Deploy,
+    node_url: &str,
+    tx_count: usize,
+) -> Result<ForcClientAccount> {
+    let provider = Provider::connect(node_url).await?;
+
+    let wallet_mode = if command.default_signer || command.signing_key.is_some() {
+        SignerSelectionMode::Manual
+    } else if let Some(arn) = &command.aws_kms_signer {
+        SignerSelectionMode::AwsSigner(arn.clone())
+    } else {
+        println_action_green("", &format!("Wallet: {}", default_wallet_path().display()));
+        let password = prompt_forc_wallet_password()?;
+        SignerSelectionMode::ForcWallet(password)
+    };
+
+    let account = select_account(
+        &wallet_mode,
+        command.default_signer || command.unsigned,
+        command.signing_key,
+        &provider,
+        tx_count,
+    )
+    .await?;
+
+    Ok(account)
+}
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/forc-plugins/forc-client/src/op/mod.rs b/forc-plugins/forc-client/src/op/mod.rs
index bb7e5746eb4..f11f8c63b7c 100644
--- a/forc-plugins/forc-client/src/op/mod.rs
+++ b/forc-plugins/forc-client/src/op/mod.rs
@@ -2,6 +2,6 @@ mod deploy;
 mod run;
 mod submit;
 
-pub use deploy::deploy;
+pub use deploy::{deploy, DeployedContract, DeployedExecutable, DeployedPackage};
 pub use run::run;
 pub use submit::submit;
diff --git a/forc-plugins/forc-client/src/op/run/encode.rs b/forc-plugins/forc-client/src/op/run/encode.rs
index c1f36524591..99473403312 100644
--- a/forc-plugins/forc-client/src/op/run/encode.rs
+++ b/forc-plugins/forc-client/src/op/run/encode.rs
@@ -62,14 +62,18 @@ impl ScriptCallHandler {
 mod tests {
     use super::{ScriptCallHandler, Type};
 
+    const TEST_JSON_ABI: &str = r#"{"programType": "contract","specVersion": "1","encodingVersion": "1","metadataTypes":[],
+    "concreteTypes":[{"concreteTypeId":"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+    "type":"()"},{"concreteTypeId":"b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903","type":"bool"},
+    {"concreteTypeId":"c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b","type":"u8"}],
+    "functions":[{"inputs":[{"name":"test_u8","concreteTypeId":"c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"},
+    {"name":"test_bool","concreteTypeId":"b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"}],"name":"main",
+    "output":"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"}],"loggedTypes":[],
+    "messagesTypes":[],"configurables":[]}"#;
+
     #[test]
     fn test_script_call_handler_generation_success() {
-        let test_json_abi = r#"{"types":[{"typeId":0,"type":"()","components":[],"typeParameters":null},
-{"typeId":1,"type":"bool","components":null,"typeParameters":null},{"typeId":2,"type":"u8","components":null,
-"typeParameters":null}],"functions":[{"inputs":[{"name":"test_u8","type":2,"typeArguments":null},{"name":"test_bool",
-"type":1,"typeArguments":null}],"name":"main","output":{"name":"","type":0,"typeArguments":null},"attributes":null}],
-"loggedTypes":[],"messagesTypes":[],"configurables":[]}"#;
-        let generated_call_handler = ScriptCallHandler::from_json_abi_str(test_json_abi).unwrap();
+        let generated_call_handler = ScriptCallHandler::from_json_abi_str(TEST_JSON_ABI).unwrap();
 
         let expected_call_handler = ScriptCallHandler {
             main_arg_types: vec![Type::U8, Type::Bool],
@@ -88,12 +92,7 @@ mod tests {
 
     #[test]
     fn test_main_encoding_success() {
-        let test_json_abi = r#"{"types":[{"typeId":0,"type":"()","components":[],"typeParameters":null},
-{"typeId":1,"type":"bool","components":null,"typeParameters":null},{"typeId":2,"type":"u8","components":null,
-"typeParameters":null}],"functions":[{"inputs":[{"name":"test_u8","type":2,"typeArguments":null},{"name":"test_bool",
-"type":1,"typeArguments":null}],"name":"main","output":{"name":"","type":0,"typeArguments":null},"attributes":null}],
-"loggedTypes":[],"messagesTypes":[],"configurables":[]}"#;
-        let call_handler = ScriptCallHandler::from_json_abi_str(test_json_abi).unwrap();
+        let call_handler = ScriptCallHandler::from_json_abi_str(TEST_JSON_ABI).unwrap();
         let values = ["2", "true"];
 
         let encoded_bytes = call_handler.encode_arguments(&values).unwrap();
@@ -104,12 +103,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_main_encoding_fail_arg_type_mismatch() {
-        let test_json_abi = r#"{"types":[{"typeId":0,"type":"()","components":[],"typeParameters":null},
-{"typeId":1,"type":"bool","components":null,"typeParameters":null},{"typeId":2,"type":"u8","components":null,
-"typeParameters":null}],"functions":[{"inputs":[{"name":"test_u8","type":2,"typeArguments":null},{"name":"test_bool",
-"type":1,"typeArguments":null}],"name":"main","output":{"name":"","type":0,"typeArguments":null},"attributes":null}],
-"loggedTypes":[],"messagesTypes":[],"configurables":[]}"#;
-        let call_handler = ScriptCallHandler::from_json_abi_str(test_json_abi).unwrap();
+        let call_handler = ScriptCallHandler::from_json_abi_str(TEST_JSON_ABI).unwrap();
         // The abi describes the following main function:
         // - fn main(test_u8: u8, test_bool: bool)
         // Providing a bool to u8 field should return an error.
@@ -120,12 +114,7 @@ mod tests {
     #[test]
     #[should_panic(expected = "main function takes 2 arguments, 1 provided")]
     fn test_main_encoding_fail_arg_count_mismatch() {
-        let test_json_abi = r#"{"types":[{"typeId":0,"type":"()","components":[],"typeParameters":null},
-{"typeId":1,"type":"bool","components":null,"typeParameters":null},{"typeId":2,"type":"u8","components":null,
-"typeParameters":null}],"functions":[{"inputs":[{"name":"test_u8","type":2,"typeArguments":null},{"name":"test_bool",
-"type":1,"typeArguments":null}],"name":"main","output":{"name":"","type":0,"typeArguments":null},"attributes":null}],
-"loggedTypes":[],"messagesTypes":[],"configurables":[]}"#;
-        let call_handler = ScriptCallHandler::from_json_abi_str(test_json_abi).unwrap();
+        let call_handler = ScriptCallHandler::from_json_abi_str(TEST_JSON_ABI).unwrap();
         // The abi describes the following main function:
         // - fn main(test_u8: u8, test_bool: bool)
         // Providing only 1 value should return an error as function requires 2 args.
diff --git a/forc-plugins/forc-client/src/op/run/mod.rs b/forc-plugins/forc-client/src/op/run/mod.rs
index 0ea4f073b2a..5e58835fca0 100644
--- a/forc-plugins/forc-client/src/op/run/mod.rs
+++ b/forc-plugins/forc-client/src/op/run/mod.rs
@@ -1,11 +1,11 @@
 mod encode;
 use crate::{
     cmd,
+    constants::TX_SUBMIT_TIMEOUT_MS,
     util::{
-        gas::get_script_gas_used,
         node_url::get_node_url,
         pkg::built_pkgs,
-        tx::{TransactionBuilderExt, WalletSelectionMode, TX_SUBMIT_TIMEOUT_MS},
+        tx::{prompt_forc_wallet_password, select_account, SignerSelectionMode},
     },
 };
 use anyhow::{anyhow, bail, Context, Result};
@@ -13,8 +13,16 @@ use forc_pkg::{self as pkg, fuel_core_not_running, PackageManifestFile};
 use forc_tracing::println_warning;
 use forc_util::tx_utils::format_log_receipts;
 use fuel_core_client::client::FuelClient;
-use fuel_tx::{ContractId, Transaction, TransactionBuilder};
-use fuels_accounts::provider::Provider;
+use fuel_tx::{ContractId, Transaction};
+use fuels::{
+    programs::calls::{traits::TransactionTuner, ScriptCall},
+    types::{
+        bech32::Bech32ContractId,
+        transaction::TxPolicies,
+        transaction_builders::{BuildableTransaction, VariableOutputPolicy},
+    },
+};
+use fuels_accounts::{provider::Provider, Account};
 use pkg::{manifest::build_profile::ExperimentalFlags, BuiltPackage};
 use std::time::Duration;
 use std::{path::PathBuf, str::FromStr};
@@ -49,6 +57,12 @@ pub async fn run(command: cmd::Run) -> Result<Vec<RanScript>> {
     };
     let build_opts = build_opts_from_cmd(&command);
     let built_pkgs_with_manifest = built_pkgs(&curr_dir, &build_opts)?;
+    let wallet_mode = if command.default_signer || command.signing_key.is_some() {
+        SignerSelectionMode::Manual
+    } else {
+        let password = prompt_forc_wallet_password()?;
+        SignerSelectionMode::ForcWallet(password)
+    };
     for built in built_pkgs_with_manifest {
         if built
             .descriptor
@@ -56,7 +70,13 @@ pub async fn run(command: cmd::Run) -> Result<Vec<RanScript>> {
             .check_program_type(&[TreeType::Script])
             .is_ok()
         {
-            let pkg_receipts = run_pkg(&command, &built.descriptor.manifest_file, &built).await?;
+            let pkg_receipts = run_pkg(
+                &command,
+                &built.descriptor.manifest_file,
+                &built,
+                &wallet_mode,
+            )
+            .await?;
             receipts.push(pkg_receipts);
         }
     }
@@ -64,12 +84,34 @@ pub async fn run(command: cmd::Run) -> Result<Vec<RanScript>> {
     Ok(receipts)
 }
 
+fn tx_policies_from_cmd(cmd: &cmd::Run) -> TxPolicies {
+    let mut tx_policies = TxPolicies::default();
+    if let Some(max_fee) = cmd.gas.max_fee {
+        tx_policies = tx_policies.with_max_fee(max_fee);
+    }
+    if let Some(script_gas_limit) = cmd.gas.script_gas_limit {
+        tx_policies = tx_policies.with_script_gas_limit(script_gas_limit);
+    }
+    tx_policies
+}
+
 pub async fn run_pkg(
     command: &cmd::Run,
     manifest: &PackageManifestFile,
     compiled: &BuiltPackage,
+    signer_mode: &SignerSelectionMode,
 ) -> Result<RanScript> {
     let node_url = get_node_url(&command.node, &manifest.network)?;
+    let provider = Provider::connect(node_url.clone()).await?;
+    let tx_count = 1;
+    let account = select_account(
+        signer_mode,
+        command.default_signer || command.unsigned,
+        command.signing_key,
+        &provider,
+        tx_count,
+    )
+    .await?;
 
     let script_data = match (&command.data, &command.args) {
         (None, Some(args)) => {
@@ -101,37 +143,29 @@ pub async fn run_pkg(
                 .map_err(|e| anyhow!("Failed to parse contract id: {}", e))
         })
         .collect::<Result<Vec<ContractId>>>()?;
-    let wallet_mode = if command.manual_signing {
-        WalletSelectionMode::Manual
-    } else {
-        WalletSelectionMode::ForcWallet
-    };
-
-    let mut tb = TransactionBuilder::script(compiled.bytecode.bytes.clone(), script_data);
-    tb.maturity(command.maturity.maturity.into())
-        .add_contracts(contract_ids);
 
-    let provider = Provider::connect(node_url.clone()).await?;
-
-    let script_gas_limit = if compiled.bytecode.bytes.is_empty() {
-        0
-    } else if let Some(script_gas_limit) = command.gas.script_gas_limit {
-        script_gas_limit
-    // Dry run tx and get `gas_used`
-    } else {
-        get_script_gas_used(tb.clone().finalize_without_signature_inner(), &provider).await?
+    let script_binary = compiled.bytecode.bytes.clone();
+    let external_contracts = contract_ids
+        .into_iter()
+        .map(Bech32ContractId::from)
+        .collect::<Vec<_>>();
+    let call = ScriptCall {
+        script_binary,
+        encoded_args: Ok(script_data),
+        inputs: vec![],
+        outputs: vec![],
+        external_contracts,
     };
-    tb.script_gas_limit(script_gas_limit);
-
-    let tx = tb
-        .finalize_signed(
-            Provider::connect(node_url.clone()).await?,
-            command.default_signer,
-            command.signing_key,
-            wallet_mode,
-        )
+    let tx_policies = tx_policies_from_cmd(command);
+    let mut tb = call
+        .transaction_builder(tx_policies, VariableOutputPolicy::EstimateMinimum, &account)
         .await?;
 
+    account.add_witnesses(&mut tb)?;
+    account.adjust_for_fee(&mut tb, 0).await?;
+
+    let tx = tb.build(provider).await?;
+
     if command.dry_run {
         info!("{:?}", tx);
         Ok(RanScript { receipts: vec![] })
@@ -212,7 +246,6 @@ fn build_opts_from_cmd(cmd: &cmd::Run) -> pkg::BuildOpts {
             terse: cmd.pkg.terse,
             locked: cmd.pkg.locked,
             output_directory: cmd.pkg.output_directory.clone(),
-            json_abi_with_callpaths: cmd.pkg.json_abi_with_callpaths,
             ipfs_node: cmd.pkg.ipfs_node.clone().unwrap_or_default(),
         },
         print: pkg::PrintOpts {
@@ -221,6 +254,7 @@ fn build_opts_from_cmd(cmd: &cmd::Run) -> pkg::BuildOpts {
             dca_graph_url_format: cmd.print.dca_graph_url_format.clone(),
             asm: cmd.print.asm(),
             bytecode: cmd.print.bytecode,
+            bytecode_spans: false,
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
diff --git a/forc-plugins/forc-client/src/util/account.rs b/forc-plugins/forc-client/src/util/account.rs
new file mode 100644
index 00000000000..17ecc6781b8
--- /dev/null
+++ b/forc-plugins/forc-client/src/util/account.rs
@@ -0,0 +1,87 @@
+use async_trait::async_trait;
+use fuel_crypto::{Message, Signature};
+use fuels::{
+    prelude::*,
+    types::{coin_type_id::CoinTypeId, input::Input},
+};
+use fuels_accounts::{wallet::WalletUnlocked, Account};
+
+use super::aws::AwsSigner;
+
+#[derive(Clone, Debug)]
+/// Set of different signers available to be used with `forc-client` operations.
+pub enum ForcClientAccount {
+    /// Local signer where the private key owned locally. This can be
+    /// generated through `forc-wallet` integration or manually by providing
+    /// a private-key.
+    Wallet(WalletUnlocked),
+    /// A KMS Signer specifically using AWS KMS service. The signing key
+    /// is managed by another entity for KMS signers. Messages are
+    /// signed by the KMS entity. Signed transactions are retrieved
+    /// and submitted to the node by `forc-client`.
+    KmsSigner(AwsSigner),
+}
+
+#[async_trait]
+impl Account for ForcClientAccount {
+    async fn get_asset_inputs_for_amount(
+        &self,
+        asset_id: AssetId,
+        amount: u64,
+        excluded_coins: Option<Vec<CoinTypeId>>,
+    ) -> Result<Vec<Input>> {
+        match self {
+            ForcClientAccount::Wallet(wallet) => {
+                wallet
+                    .get_asset_inputs_for_amount(asset_id, amount, excluded_coins)
+                    .await
+            }
+            ForcClientAccount::KmsSigner(account) => {
+                account
+                    .get_asset_inputs_for_amount(asset_id, amount, excluded_coins)
+                    .await
+            }
+        }
+    }
+
+    fn add_witnesses<Tb: TransactionBuilder>(&self, tb: &mut Tb) -> Result<()> {
+        tb.add_signer(self.clone())?;
+
+        Ok(())
+    }
+}
+
+impl ViewOnlyAccount for ForcClientAccount {
+    fn address(&self) -> &Bech32Address {
+        match self {
+            ForcClientAccount::Wallet(wallet) => wallet.address(),
+            ForcClientAccount::KmsSigner(account) => {
+                fuels_accounts::ViewOnlyAccount::address(account)
+            }
+        }
+    }
+
+    fn try_provider(&self) -> Result<&Provider> {
+        match self {
+            ForcClientAccount::Wallet(wallet) => wallet.try_provider(),
+            ForcClientAccount::KmsSigner(account) => Ok(account.provider()),
+        }
+    }
+}
+
+#[async_trait]
+impl Signer for ForcClientAccount {
+    async fn sign(&self, message: Message) -> Result<Signature> {
+        match self {
+            ForcClientAccount::Wallet(wallet) => wallet.sign(message).await,
+            ForcClientAccount::KmsSigner(account) => account.sign(message).await,
+        }
+    }
+
+    fn address(&self) -> &Bech32Address {
+        match self {
+            ForcClientAccount::Wallet(wallet) => wallet.address(),
+            ForcClientAccount::KmsSigner(account) => fuels_core::traits::Signer::address(account),
+        }
+    }
+}
diff --git a/forc-plugins/forc-client/src/util/aws.rs b/forc-plugins/forc-client/src/util/aws.rs
new file mode 100644
index 00000000000..90da533815c
--- /dev/null
+++ b/forc-plugins/forc-client/src/util/aws.rs
@@ -0,0 +1,269 @@
+use async_trait::async_trait;
+use aws_config::{default_provider::credentials::DefaultCredentialsChain, Region, SdkConfig};
+use aws_sdk_kms::config::Credentials;
+use aws_sdk_kms::operation::get_public_key::GetPublicKeyOutput;
+use aws_sdk_kms::primitives::Blob;
+use aws_sdk_kms::types::{MessageType, SigningAlgorithmSpec};
+use aws_sdk_kms::{config::BehaviorVersion, Client};
+use fuel_crypto::Message;
+use fuels::prelude::*;
+use fuels::types::bech32::{Bech32Address, FUEL_BECH32_HRP};
+use fuels::types::coin_type_id::CoinTypeId;
+use fuels::types::input::Input;
+use fuels_accounts::provider::Provider;
+use fuels_accounts::{Account, ViewOnlyAccount};
+use fuels_core::traits::Signer;
+
+/// AWS configuration for the `AwsSigner` to be created.
+/// De-facto way of creating the configuration is to load it from env.
+#[derive(Debug, Clone)]
+pub struct AwsConfig {
+    sdk_config: SdkConfig,
+}
+
+impl AwsConfig {
+    /// Load configuration from environment variables.
+    /// For more details see: https://docs.rs/aws-config/latest/aws_config/
+    pub async fn from_env() -> Self {
+        let loader = aws_config::defaults(BehaviorVersion::latest())
+            .credentials_provider(DefaultCredentialsChain::builder().build().await);
+
+        let loader = match std::env::var("E2E_TEST_AWS_ENDPOINT") {
+            Ok(url) => loader.endpoint_url(url),
+            _ => loader,
+        };
+
+        Self {
+            sdk_config: loader.load().await,
+        }
+    }
+
+    pub async fn for_testing(url: String) -> Self {
+        let sdk_config = aws_config::defaults(BehaviorVersion::latest())
+            .credentials_provider(Credentials::new(
+                "test",
+                "test",
+                None,
+                None,
+                "Static Credentials",
+            ))
+            .endpoint_url(url)
+            .region(Region::new("us-east-1")) // placeholder region for test
+            .load()
+            .await;
+
+        Self { sdk_config }
+    }
+
+    pub fn url(&self) -> Option<&str> {
+        self.sdk_config.endpoint_url()
+    }
+
+    pub fn region(&self) -> Option<&Region> {
+        self.sdk_config.region()
+    }
+}
+
+/// A configured `AwsClient` which allows using the AWS KMS SDK.
+#[derive(Clone, Debug)]
+pub struct AwsClient {
+    client: Client,
+}
+
+impl AwsClient {
+    pub fn new(config: AwsConfig) -> Self {
+        let config = config.sdk_config;
+        let client = Client::new(&config);
+
+        Self { client }
+    }
+
+    pub fn inner(&self) -> &Client {
+        &self.client
+    }
+}
+
+/// A signer which is capable of signing `fuel_crypto::Message`s using AWS KMS.
+/// This is both a `Signer` and `Account`, which means it is directly usable
+/// with most of the fuels-* calls, without any additional operations on the
+/// representation.
+#[derive(Clone, Debug)]
+pub struct AwsSigner {
+    kms: AwsClient,
+    key_id: String,
+    bech: Bech32Address,
+    public_key_bytes: Vec<u8>,
+    provider: Provider,
+}
+
+async fn request_get_pubkey(
+    kms: &Client,
+    key_id: String,
+) -> std::result::Result<GetPublicKeyOutput, anyhow::Error> {
+    kms.get_public_key()
+        .key_id(key_id)
+        .send()
+        .await
+        .map_err(Into::into)
+}
+
+/// Decode an AWS KMS Pubkey response.
+fn decode_pubkey(resp: &GetPublicKeyOutput) -> std::result::Result<Vec<u8>, anyhow::Error> {
+    let raw = resp
+        .public_key
+        .as_ref()
+        .ok_or(anyhow::anyhow!("public key not found"))?;
+    Ok(raw.clone().into_inner())
+}
+
+async fn sign_with_kms(
+    client: &aws_sdk_kms::Client,
+    key_id: &str,
+    public_key_bytes: &[u8],
+    message: Message,
+) -> anyhow::Result<fuel_crypto::Signature> {
+    use k256::{
+        ecdsa::{RecoveryId, VerifyingKey},
+        pkcs8::DecodePublicKey,
+    };
+
+    let reply = client
+        .sign()
+        .key_id(key_id)
+        .signing_algorithm(SigningAlgorithmSpec::EcdsaSha256)
+        .message_type(MessageType::Digest)
+        .message(Blob::new(*message))
+        .send()
+        .await
+        .inspect_err(|err| tracing::error!("Failed to sign with AWS KMS: {err:?}"))?;
+    let signature_der = reply
+        .signature
+        .ok_or_else(|| anyhow::anyhow!("no signature returned from AWS KMS"))?
+        .into_inner();
+    // https://stackoverflow.com/a/71475108
+    let sig = k256::ecdsa::Signature::from_der(&signature_der)
+        .map_err(|_| anyhow::anyhow!("invalid DER signature from AWS KMS"))?;
+    let sig = sig.normalize_s().unwrap_or(sig);
+
+    // This is a hack to get the recovery id. The signature should be normalized
+    // before computing the recovery id, but aws kms doesn't support this, and
+    // instead always computes the recovery id from non-normalized signature.
+    // So instead the recovery id is determined by checking which variant matches
+    // the original public key.
+
+    let recid1 = RecoveryId::new(false, false);
+    let recid2 = RecoveryId::new(true, false);
+
+    let rec1 = VerifyingKey::recover_from_prehash(&*message, &sig, recid1);
+    let rec2 = VerifyingKey::recover_from_prehash(&*message, &sig, recid2);
+
+    let correct_public_key = k256::PublicKey::from_public_key_der(public_key_bytes)
+        .map_err(|_| anyhow::anyhow!("invalid DER public key from AWS KMS"))?
+        .into();
+
+    let recovery_id = if rec1.map(|r| r == correct_public_key).unwrap_or(false) {
+        recid1
+    } else if rec2.map(|r| r == correct_public_key).unwrap_or(false) {
+        recid2
+    } else {
+        anyhow::bail!("Invalid signature generated (reduced-x form coordinate)");
+    };
+
+    // Insert the recovery id into the signature
+    debug_assert!(
+        !recovery_id.is_x_reduced(),
+        "reduced-x form coordinates are caught by the if-else chain above"
+    );
+    let v = recovery_id.is_y_odd() as u8;
+    let mut signature = <[u8; 64]>::from(sig.to_bytes());
+    signature[32] = (v << 7) | (signature[32] & 0x7f);
+    Ok(fuel_crypto::Signature::from_bytes(signature))
+}
+
+impl AwsSigner {
+    pub async fn new(
+        kms: AwsClient,
+        key_id: String,
+        provider: Provider,
+    ) -> std::result::Result<Self, anyhow::Error> {
+        use k256::pkcs8::DecodePublicKey;
+
+        let resp = request_get_pubkey(kms.inner(), key_id.clone()).await?;
+        let public_key_bytes = decode_pubkey(&resp)?;
+        let k256_public_key = k256::PublicKey::from_public_key_der(&public_key_bytes)?;
+
+        let public_key = fuel_crypto::PublicKey::from(k256_public_key);
+        let hashed = public_key.hash();
+        let bech = Bech32Address::new(FUEL_BECH32_HRP, hashed);
+        Ok(Self {
+            kms,
+            key_id,
+            bech,
+            public_key_bytes,
+            provider,
+        })
+    }
+
+    /// Sign a digest with the key associated with a key ID.
+    pub async fn sign_message_with_key(
+        &self,
+        key_id: String,
+        message: Message,
+    ) -> std::result::Result<fuel_crypto::Signature, anyhow::Error> {
+        sign_with_kms(self.kms.inner(), &key_id, &self.public_key_bytes, message).await
+    }
+
+    /// Sign a digest with this signer's key.
+    pub async fn sign_message(
+        &self,
+        message: Message,
+    ) -> std::result::Result<fuel_crypto::Signature, anyhow::Error> {
+        self.sign_message_with_key(self.key_id.clone(), message)
+            .await
+    }
+
+    pub fn provider(&self) -> &Provider {
+        &self.provider
+    }
+}
+
+#[async_trait]
+impl Signer for AwsSigner {
+    async fn sign(&self, message: Message) -> Result<fuel_crypto::Signature> {
+        let sig = self.sign_message(message).await.map_err(|_| {
+            fuels_core::types::errors::Error::Other("aws signer failed".to_string())
+        })?;
+        Ok(sig)
+    }
+
+    fn address(&self) -> &Bech32Address {
+        &self.bech
+    }
+}
+
+impl ViewOnlyAccount for AwsSigner {
+    fn address(&self) -> &Bech32Address {
+        &self.bech
+    }
+
+    fn try_provider(&self) -> Result<&Provider> {
+        Ok(&self.provider)
+    }
+}
+
+#[async_trait]
+impl Account for AwsSigner {
+    async fn get_asset_inputs_for_amount(
+        &self,
+        asset_id: AssetId,
+        amount: u64,
+        excluded_coins: Option<Vec<CoinTypeId>>,
+    ) -> Result<Vec<Input>> {
+        Ok(self
+            .get_spendable_resources(asset_id, amount, excluded_coins)
+            .await?
+            .into_iter()
+            .map(Input::resource_signed)
+            .collect::<Vec<Input>>())
+    }
+}
diff --git a/forc-plugins/forc-client/src/util/gas.rs b/forc-plugins/forc-client/src/util/gas.rs
deleted file mode 100644
index 8ccc885488f..00000000000
--- a/forc-plugins/forc-client/src/util/gas.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-use anyhow::Result;
-
-use fuel_core_client::client::FuelClient;
-use fuel_core_types::services::executor::TransactionExecutionResult;
-use fuel_tx::{
-    field::{Inputs, MaxFeeLimit, Witnesses},
-    Buildable, Chargeable, Create, Input, Script, Transaction, TxPointer,
-};
-use fuels_accounts::provider::Provider;
-use fuels_core::{
-    constants::DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON, types::transaction_builders::DryRunner,
-};
-
-fn no_spendable_input<'a, I: IntoIterator<Item = &'a Input>>(inputs: I) -> bool {
-    !inputs.into_iter().any(|i| {
-        matches!(
-            i,
-            Input::CoinSigned(_)
-                | Input::CoinPredicate(_)
-                | Input::MessageCoinSigned(_)
-                | Input::MessageCoinPredicate(_)
-        )
-    })
-}
-
-pub(crate) async fn get_script_gas_used(mut tx: Script, provider: &Provider) -> Result<u64> {
-    let no_spendable_input = no_spendable_input(tx.inputs());
-    let base_asset_id = provider.base_asset_id();
-    if no_spendable_input {
-        tx.inputs_mut().push(Input::coin_signed(
-            Default::default(),
-            Default::default(),
-            1_000_000_000,
-            *base_asset_id,
-            TxPointer::default(),
-            0,
-        ));
-
-        // Add an empty `Witness` for the `coin_signed` we just added
-        // and increase the witness limit
-        tx.witnesses_mut().push(Default::default());
-    }
-    let consensus_params = provider.consensus_parameters();
-
-    // Get `max_gas` used by everything except the script execution. Add `1` because of rounding.
-    let max_gas_per_tx = consensus_params.tx_params().max_gas_per_tx();
-    let max_gas = tx.max_gas(consensus_params.gas_costs(), consensus_params.fee_params()) + 1;
-    // Increase `script_gas_limit` to the maximum allowed value.
-    tx.set_script_gas_limit(max_gas_per_tx - max_gas);
-
-    get_gas_used(Transaction::Script(tx), provider).await
-}
-
-/// Returns gas_used for an arbitrary tx, by doing dry run with the provided `Provider`.
-pub(crate) async fn get_gas_used(tx: Transaction, provider: &Provider) -> Result<u64> {
-    let tolerance = 0.1;
-    let gas_used = provider.dry_run_and_get_used_gas(tx, tolerance).await?;
-    Ok(gas_used)
-}
-
-/// Returns an estimation for the max fee of `Create` transactions.
-/// Accepts a `tolerance` which is used to add some safety margin to the estimation.
-/// Resulting estimation is calculated as `(dry_run_estimation * tolerance)/100 + dry_run_estimation)`.
-pub(crate) async fn get_estimated_max_fee(
-    tx: Create,
-    provider: &Provider,
-    client: &FuelClient,
-    tolerance: u64,
-) -> Result<u64> {
-    let mut tx = tx.clone();
-    // Add dummy input to get past validation for dry run.
-    let no_spendable_input = no_spendable_input(tx.inputs());
-    let base_asset_id = provider.base_asset_id();
-    if no_spendable_input {
-        tx.inputs_mut().push(Input::coin_signed(
-            Default::default(),
-            Default::default(),
-            1_000_000_000,
-            *base_asset_id,
-            TxPointer::default(),
-            0,
-        ));
-
-        // Add an empty `Witness` for the `coin_signed` we just added
-        // and increase the witness limit
-        tx.witnesses_mut().push(Default::default());
-    }
-    let consensus_params = provider.consensus_parameters();
-    let gas_price = provider
-        .estimate_gas_price(DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON)
-        .await?
-        .gas_price;
-    let max_fee = tx.max_fee(
-        consensus_params.gas_costs(),
-        consensus_params.fee_params(),
-        gas_price,
-    );
-    tx.set_max_fee_limit(max_fee as u64);
-    let tx = Transaction::from(tx);
-
-    let tx_status = client
-        .dry_run_opt(&[tx], Some(false))
-        .await
-        .map(|mut status_vec| status_vec.remove(0))?;
-    let total_fee = match tx_status.result {
-        TransactionExecutionResult::Success { total_fee, .. } => total_fee,
-        TransactionExecutionResult::Failed { total_fee, .. } => total_fee,
-    };
-
-    let total_fee_with_tolerance = ((total_fee * tolerance) / 100) + total_fee;
-    Ok(total_fee_with_tolerance)
-}
diff --git a/forc-plugins/forc-client/src/util/mod.rs b/forc-plugins/forc-client/src/util/mod.rs
index 3b99a89659f..2e58fc41c79 100644
--- a/forc-plugins/forc-client/src/util/mod.rs
+++ b/forc-plugins/forc-client/src/util/mod.rs
@@ -1,6 +1,7 @@
+pub mod account;
+pub mod aws;
 pub(crate) mod encode;
-pub(crate) mod gas;
 pub(crate) mod node_url;
 pub(crate) mod pkg;
 pub(crate) mod target;
-pub(crate) mod tx;
+pub mod tx;
diff --git a/forc-plugins/forc-client/src/util/node_url.rs b/forc-plugins/forc-client/src/util/node_url.rs
index b7fe3f8bf39..58e9dcd87e1 100644
--- a/forc-plugins/forc-client/src/util/node_url.rs
+++ b/forc-plugins/forc-client/src/util/node_url.rs
@@ -12,18 +12,22 @@ pub fn get_node_url(
 ) -> Result<String> {
     let node_url = match (
         node_target.testnet,
+        node_target.mainnet,
         node_target.target.clone(),
         node_target.node_url.clone(),
     ) {
-        (true, None, None) => Target::testnet().target_url(),
-        (false, Some(target), None) => target.target_url(),
-        (false, None, Some(node_url)) => node_url,
-        (false, None, None) => manifest_network
+        (true, false, None, None) => Target::testnet().target_url(),
+        (false, true, None, None) => Target::mainnet().target_url(),
+        (false, false, Some(target), None) => target.target_url(),
+        (false, false, None, Some(node_url)) => node_url,
+        (false, false, None, None) => manifest_network
             .as_ref()
             .map(|nw| &nw.url[..])
             .unwrap_or(crate::constants::NODE_URL)
             .to_string(),
-        _ => bail!("Only one of `--testnet`, `--target`, or `--node-url` should be specified"),
+        _ => bail!(
+            "Only one of `--testnet`, `--mainnet`, `--target`, or `--node-url` should be specified"
+        ),
     };
 
     Ok(node_url)
@@ -35,6 +39,7 @@ fn test_get_node_url_testnet() {
         target: None,
         node_url: None,
         testnet: true,
+        mainnet: false,
     };
 
     let actual = get_node_url(&input, &None).unwrap();
@@ -42,63 +47,41 @@ fn test_get_node_url_testnet() {
 }
 
 #[test]
-fn test_get_node_url_target_devnet() {
+fn test_get_node_url_mainnet() {
     let input = NodeTarget {
-        target: Some(Target::Devnet),
-        node_url: None,
-        testnet: false,
-    };
-    let actual = get_node_url(&input, &None).unwrap();
-    assert_eq!("https://devnet.fuel.network", actual);
-}
-
-#[test]
-fn test_get_node_url_target_testnet() {
-    let input = NodeTarget {
-        target: Some(Target::Testnet),
+        target: None,
         node_url: None,
         testnet: false,
+        mainnet: true,
     };
 
     let actual = get_node_url(&input, &None).unwrap();
-    assert_eq!("https://testnet.fuel.network", actual);
+    assert_eq!("https://mainnet.fuel.network", actual);
 }
 
 #[test]
-fn test_get_node_url_beta5() {
+fn test_get_node_url_target_mainnet() {
     let input = NodeTarget {
-        target: Some(Target::Beta5),
+        target: Some(Target::Mainnet),
         node_url: None,
         testnet: false,
+        mainnet: false,
     };
     let actual = get_node_url(&input, &None).unwrap();
-    assert_eq!("https://beta-5.fuel.network", actual);
+    assert_eq!("https://mainnet.fuel.network", actual);
 }
 
 #[test]
-fn test_get_node_url_beta4() {
-    let input = NodeTarget {
-        target: None,
-        node_url: Some("https://beta-4.fuel.network".to_string()),
-        testnet: false,
-    };
-    let actual = get_node_url(&input, &None).unwrap();
-    assert_eq!("https://beta-4.fuel.network", actual);
-}
-
-#[test]
-fn test_get_node_url_url_beta4_manifest() {
-    let network = Network {
-        url: "https://beta-4.fuel.network".to_string(),
-    };
+fn test_get_node_url_target_testnet() {
     let input = NodeTarget {
-        target: None,
+        target: Some(Target::Testnet),
         node_url: None,
         testnet: false,
+        mainnet: false,
     };
 
-    let actual = get_node_url(&input, &Some(network)).unwrap();
-    assert_eq!("https://beta-4.fuel.network", actual);
+    let actual = get_node_url(&input, &None).unwrap();
+    assert_eq!("https://testnet.fuel.network", actual);
 }
 
 #[test]
@@ -107,29 +90,20 @@ fn test_get_node_url_default() {
         target: None,
         node_url: None,
         testnet: false,
+        mainnet: false,
     };
 
     let actual = get_node_url(&input, &None).unwrap();
     assert_eq!("http://127.0.0.1:4000", actual);
 }
 
-#[test]
-fn test_get_node_url_beta3() {
-    let input = NodeTarget {
-        target: Some(Target::Beta3),
-        node_url: None,
-        testnet: false,
-    };
-    let actual = get_node_url(&input, &None).unwrap();
-    assert_eq!("https://beta-3.fuel.network", actual);
-}
-
 #[test]
 fn test_get_node_url_local() {
     let input = NodeTarget {
         target: Some(Target::Local),
         node_url: None,
         testnet: false,
+        mainnet: false,
     };
     let actual = get_node_url(&input, &None).unwrap();
     assert_eq!("http://127.0.0.1:4000", actual);
@@ -137,26 +111,28 @@ fn test_get_node_url_local() {
 
 #[test]
 #[should_panic(
-    expected = "Only one of `--testnet`, `--target`, or `--node-url` should be specified"
+    expected = "Only one of `--testnet`, `--mainnet`, `--target`, or `--node-url` should be specified"
 )]
 fn test_get_node_url_local_testnet() {
     let input = NodeTarget {
         target: Some(Target::Local),
         node_url: None,
         testnet: true,
+        mainnet: false,
     };
     get_node_url(&input, &None).unwrap();
 }
 
 #[test]
 #[should_panic(
-    expected = "Only one of `--testnet`, `--target`, or `--node-url` should be specified"
+    expected = "Only one of `--testnet`, `--mainnet`, `--target`, or `--node-url` should be specified"
 )]
 fn test_get_node_url_same_url() {
     let input = NodeTarget {
-        target: Some(Target::Beta3),
-        node_url: Some("beta-3.fuel.network".to_string()),
+        target: Some(Target::Testnet),
+        node_url: Some("testnet.fuel.network".to_string()),
         testnet: false,
+        mainnet: false,
     };
     get_node_url(&input, &None).unwrap();
 }
diff --git a/forc-plugins/forc-client/src/util/pkg.rs b/forc-plugins/forc-client/src/util/pkg.rs
index f7b6384cb74..c93df24bacc 100644
--- a/forc-plugins/forc-client/src/util/pkg.rs
+++ b/forc-plugins/forc-client/src/util/pkg.rs
@@ -1,9 +1,62 @@
 use anyhow::Result;
 use forc_pkg::manifest::GenericManifestFile;
 use forc_pkg::{self as pkg, manifest::ManifestFile, BuildOpts, BuildPlan};
-use pkg::{build_with_options, BuiltPackage};
+use forc_util::user_forc_directory;
+use pkg::{build_with_options, BuiltPackage, PackageManifestFile};
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
 use std::{collections::HashMap, path::Path, sync::Arc};
 
+/// The name of the folder that forc generated proxy contract project will reside at.
+pub const GENERATED_CONTRACT_FOLDER_NAME: &str = ".generated_contracts";
+pub const PROXY_CONTRACT_BIN: &[u8] = include_bytes!("../../proxy_abi/proxy_contract.bin");
+pub const PROXY_CONTRACT_STORAGE_SLOTS: &str =
+    include_str!("../../proxy_abi/proxy_contract-storage_slots.json");
+pub const PROXY_BIN_FILE_NAME: &str = "proxy.bin";
+pub const PROXY_STORAGE_SLOTS_FILE_NAME: &str = "proxy-storage_slots.json";
+
+/// Updates the given package manifest file such that the address field under the proxy table updated to the given value.
+/// Updated manifest file is written back to the same location, without thouching anything else such as comments etc.
+/// A safety check is done to ensure the proxy table exists before attempting to udpdate the value.
+pub(crate) fn update_proxy_address_in_manifest(
+    address: &str,
+    manifest: &PackageManifestFile,
+) -> Result<()> {
+    let mut toml = String::new();
+    let mut file = File::open(manifest.path())?;
+    file.read_to_string(&mut toml)?;
+    let mut manifest_toml = toml.parse::<toml_edit::DocumentMut>()?;
+    if manifest.proxy().is_some() {
+        manifest_toml["proxy"]["address"] = toml_edit::value(address);
+        let mut file = std::fs::OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .open(manifest.path())?;
+        file.write_all(manifest_toml.to_string().as_bytes())?;
+    }
+    Ok(())
+}
+
+/// Creates a proxy contract project at the given path, adds a forc.toml and source file.
+pub(crate) fn create_proxy_contract(pkg_name: &str) -> Result<PathBuf> {
+    // Create the proxy contract folder.
+    let proxy_contract_dir = user_forc_directory()
+        .join(GENERATED_CONTRACT_FOLDER_NAME)
+        .join(format!("{}-proxy", pkg_name));
+    std::fs::create_dir_all(&proxy_contract_dir)?;
+    std::fs::write(
+        proxy_contract_dir.join(PROXY_BIN_FILE_NAME),
+        PROXY_CONTRACT_BIN,
+    )?;
+    std::fs::write(
+        proxy_contract_dir.join(PROXY_STORAGE_SLOTS_FILE_NAME),
+        PROXY_CONTRACT_STORAGE_SLOTS,
+    )?;
+
+    Ok(proxy_contract_dir)
+}
+
 pub(crate) fn built_pkgs(path: &Path, build_opts: &BuildOpts) -> Result<Vec<Arc<BuiltPackage>>> {
     let manifest_file = ManifestFile::from_dir(path)?;
     let lock_path = manifest_file.lock_path()?;
diff --git a/forc-plugins/forc-client/src/util/target.rs b/forc-plugins/forc-client/src/util/target.rs
index 8c9d598ab4d..bbc5679e844 100644
--- a/forc-plugins/forc-client/src/util/target.rs
+++ b/forc-plugins/forc-client/src/util/target.rs
@@ -1,7 +1,6 @@
 use crate::constants::{
-    BETA_2_ENDPOINT_URL, BETA_2_FAUCET_URL, BETA_3_ENDPOINT_URL, BETA_3_FAUCET_URL,
-    BETA_4_ENDPOINT_URL, BETA_4_FAUCET_URL, BETA_5_ENDPOINT_URL, BETA_5_FAUCET_URL,
-    DEVNET_ENDPOINT_URL, DEVNET_FAUCET_URL, NODE_URL, TESTNET_ENDPOINT_URL, TESTNET_FAUCET_URL,
+    MAINNET_ENDPOINT_URL, MAINNET_EXPLORER_URL, NODE_URL, TESTNET_ENDPOINT_URL,
+    TESTNET_EXPLORER_URL, TESTNET_FAUCET_URL,
 };
 use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
@@ -10,12 +9,8 @@ use std::str::FromStr;
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 /// Possible target values that forc-client can interact with.
 pub enum Target {
-    Beta2,
-    Beta3,
-    Beta4,
-    Beta5,
-    Devnet,
     Testnet,
+    Mainnet,
     Local,
 }
 
@@ -28,12 +23,8 @@ impl Default for Target {
 impl Target {
     pub fn target_url(&self) -> String {
         let url = match self {
-            Target::Beta2 => BETA_2_ENDPOINT_URL,
-            Target::Beta3 => BETA_3_ENDPOINT_URL,
-            Target::Beta4 => BETA_4_ENDPOINT_URL,
-            Target::Beta5 => BETA_5_ENDPOINT_URL,
-            Target::Devnet => DEVNET_ENDPOINT_URL,
             Target::Testnet => TESTNET_ENDPOINT_URL,
+            Target::Mainnet => MAINNET_ENDPOINT_URL,
             Target::Local => NODE_URL,
         };
         url.to_string()
@@ -41,30 +32,38 @@ impl Target {
 
     pub fn from_target_url(target_url: &str) -> Option<Self> {
         match target_url {
-            BETA_2_ENDPOINT_URL => Some(Target::Beta2),
-            BETA_3_ENDPOINT_URL => Some(Target::Beta3),
-            BETA_4_ENDPOINT_URL => Some(Target::Beta4),
-            BETA_5_ENDPOINT_URL => Some(Target::Beta5),
-            DEVNET_ENDPOINT_URL => Some(Target::Devnet),
             TESTNET_ENDPOINT_URL => Some(Target::Testnet),
+            MAINNET_ENDPOINT_URL => Some(Target::Mainnet),
             NODE_URL => Some(Target::Local),
             _ => None,
         }
     }
 
+    pub fn local() -> Self {
+        Target::Local
+    }
+
     pub fn testnet() -> Self {
         Target::Testnet
     }
 
-    pub fn faucet_url(&self) -> String {
+    pub fn mainnet() -> Self {
+        Target::Mainnet
+    }
+
+    pub fn faucet_url(&self) -> Option<String> {
         match self {
-            Target::Beta2 => BETA_2_FAUCET_URL.to_string(),
-            Target::Beta3 => BETA_3_FAUCET_URL.to_string(),
-            Target::Beta4 => BETA_4_FAUCET_URL.to_string(),
-            Target::Beta5 => BETA_5_FAUCET_URL.to_string(),
-            Target::Devnet => DEVNET_FAUCET_URL.to_string(),
-            Target::Testnet => TESTNET_FAUCET_URL.to_string(),
-            Target::Local => "http://localhost:3000".to_string(),
+            Target::Testnet => Some(TESTNET_FAUCET_URL.to_string()),
+            Target::Mainnet => None,
+            Target::Local => Some("http://localhost:3000".to_string()),
+        }
+    }
+
+    pub fn explorer_url(&self) -> Option<String> {
+        match self {
+            Target::Testnet => Some(TESTNET_EXPLORER_URL.to_string()),
+            Target::Mainnet => Some(MAINNET_EXPLORER_URL.to_string()),
+            _ => None,
         }
     }
 }
@@ -74,21 +73,13 @@ impl FromStr for Target {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "beta-2" => Ok(Target::Beta2),
-            "beta-3" => Ok(Target::Beta3),
-            "beta-4" => Ok(Target::Beta4),
-            "beta-5" => Ok(Target::Beta5),
-            "devnet" => Ok(Target::Devnet),
-            "testnet" => Ok(Target::Testnet),
+            "Fuel Sepolia Testnet" => Ok(Target::Testnet),
+            "Ignition" => Ok(Target::Mainnet),
             "local" => Ok(Target::Local),
             _ => bail!(
-                "'{s}' is not a valid target name. Possible values: '{}', '{}', '{}', '{}', '{}', '{}', '{}'",
-                Target::Beta2,
-                Target::Beta3,
-                Target::Beta4,
-                Target::Beta5,
-                Target::Devnet,
+                "'{s}' is not a valid target name. Possible values: '{}', '{}', '{}'",
                 Target::Testnet,
+                Target::Mainnet,
                 Target::Local
             ),
         }
@@ -98,12 +89,8 @@ impl FromStr for Target {
 impl std::fmt::Display for Target {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = match self {
-            Target::Beta2 => "beta-2",
-            Target::Beta3 => "beta-3",
-            Target::Beta4 => "beta-4",
-            Target::Beta5 => "beta-5",
-            Target::Devnet => "devnet",
-            Target::Testnet => "testnet",
+            Target::Testnet => "Fuel Sepolia Testnet",
+            Target::Mainnet => "Ignition",
             Target::Local => "local",
         };
         write!(f, "{}", s)
diff --git a/forc-plugins/forc-client/src/util/tx.rs b/forc-plugins/forc-client/src/util/tx.rs
index 84441b79933..e9f8b220121 100644
--- a/forc-plugins/forc-client/src/util/tx.rs
+++ b/forc-plugins/forc-client/src/util/tx.rs
@@ -1,71 +1,126 @@
-use std::{io::Write, str::FromStr};
-
-use anyhow::{Error, Result};
-use async_trait::async_trait;
-use forc_tracing::println_warning;
-
-use fuel_crypto::{Message, PublicKey, SecretKey, Signature};
-use fuel_tx::{field, Address, Buildable, ContractId, Input, Output, TransactionBuilder, Witness};
-use fuels_accounts::{provider::Provider, wallet::Wallet, ViewOnlyAccount};
-use fuels_core::types::{
-    bech32::{Bech32Address, FUEL_BECH32_HRP},
-    coin_type::CoinType,
-    transaction_builders::{create_coin_input, create_coin_message_input},
+use crate::{
+    constants::DEFAULT_PRIVATE_KEY,
+    util::{account::ForcClientAccount, aws::AwsSigner, target::Target},
 };
-
+use anyhow::Result;
+use dialoguer::{theme::ColorfulTheme, Confirm, Password, Select};
+use forc_tracing::{println_action_green, println_warning};
 use forc_wallet::{
     account::{derive_secret_key, new_at_index_cli},
     balance::{
-        collect_accounts_with_verification, print_account_balances, AccountBalances,
-        AccountVerification, AccountsMap,
+        collect_accounts_with_verification, AccountBalances, AccountVerification, AccountsMap,
     },
     new::{new_wallet_cli, New},
     utils::default_wallet_path,
 };
+use fuel_crypto::SecretKey;
+use fuel_tx::{AssetId, ContractId};
+use fuels::{
+    macros::abigen, programs::responses::CallResponse, types::checksum_address::checksum_encode,
+};
+use fuels_accounts::{
+    provider::Provider,
+    wallet::{Wallet, WalletUnlocked},
+    ViewOnlyAccount,
+};
+use std::{collections::BTreeMap, path::Path, str::FromStr};
 
-use crate::util::target::Target;
-
-/// The maximum time to wait for a transaction to be included in a block by the node
-pub const TX_SUBMIT_TIMEOUT_MS: u64 = 30_000u64;
-
-/// Default PrivateKey to sign transactions submitted to local node.
-pub const DEFAULT_PRIVATE_KEY: &str =
-    "0xde97d8624a438121b86a1956544bd72ed68cd69f2c99555b08b1e8c51ffd511c";
+use super::aws::{AwsClient, AwsConfig};
 
 #[derive(PartialEq, Eq)]
-pub enum WalletSelectionMode {
-    ForcWallet,
+pub enum SignerSelectionMode {
+    /// Holds the password of forc-wallet instance.
+    ForcWallet(String),
+    /// Holds ARN of the AWS signer.
+    AwsSigner(String),
     Manual,
 }
 
-fn prompt_address() -> Result<Bech32Address> {
-    print!("Please provide the address of the wallet you are going to sign this transaction with:");
-    std::io::stdout().flush()?;
-    let mut buf = String::new();
-    std::io::stdin().read_line(&mut buf)?;
-    Bech32Address::from_str(buf.trim()).map_err(Error::msg)
+fn ask_user_yes_no_question(question: &str) -> Result<bool> {
+    let answer = Confirm::with_theme(&ColorfulTheme::default())
+        .with_prompt(question)
+        .default(false)
+        .show_default(false)
+        .interact()?;
+    Ok(answer)
+}
+
+fn collect_user_accounts(
+    wallet_path: &Path,
+    password: &str,
+) -> Result<BTreeMap<usize, fuel_tx::Address>> {
+    let verification = AccountVerification::Yes(password.to_string());
+    let accounts = collect_accounts_with_verification(wallet_path, verification).map_err(|e| {
+        if e.to_string().contains("Mac Mismatch") {
+            anyhow::anyhow!("Failed to access forc-wallet vault. Please check your password")
+        } else {
+            e
+        }
+    })?;
+    Ok(accounts)
 }
 
-fn prompt_signature(tx_id: fuel_tx::Bytes32) -> Result<Signature> {
-    println!("Transaction id to sign: {tx_id}");
-    print!("Please provide the signature:");
-    std::io::stdout().flush()?;
-    let mut buf = String::new();
-    std::io::stdin().read_line(&mut buf)?;
-    Signature::from_str(buf.trim()).map_err(Error::msg)
+pub(crate) fn prompt_forc_wallet_password() -> Result<String> {
+    let password = Password::with_theme(&ColorfulTheme::default())
+        .with_prompt("Wallet password")
+        .allow_empty_password(true)
+        .interact()?;
+
+    Ok(password)
 }
 
-fn ask_user_yes_no_question(question: &str) -> Result<bool> {
-    print!("{question}");
-    std::io::stdout().flush()?;
-    let mut ans = String::new();
-    std::io::stdin().read_line(&mut ans)?;
-    // Pop trailing \n as users press enter to submit their answers.
-    ans.pop();
-    // Trim the user input as it might have an additional space.
-    let ans = ans.trim();
-    Ok(ans == "y" || ans == "Y")
+pub(crate) fn check_and_create_wallet_at_default_path(wallet_path: &Path) -> Result<()> {
+    if !wallet_path.exists() {
+        let question = format!("Could not find a wallet at {wallet_path:?}, would you like to create a new one? [y/N]: ");
+        let accepted = ask_user_yes_no_question(&question)?;
+        let new_options = New {
+            force: false,
+            cache_accounts: None,
+        };
+        if accepted {
+            new_wallet_cli(wallet_path, new_options)?;
+            println!("Wallet created successfully.");
+            // Derive first account for the fresh wallet we created.
+            new_at_index_cli(wallet_path, 0)?;
+            println!("Account derived successfully.");
+        } else {
+            anyhow::bail!("Refused to create a new wallet. If you don't want to use forc-wallet, you can sign this transaction manually with --manual-signing flag.")
+        }
+    }
+    Ok(())
 }
+
+pub(crate) fn secret_key_from_forc_wallet(
+    wallet_path: &Path,
+    account_index: usize,
+    password: &str,
+) -> Result<SecretKey> {
+    let secret_key = derive_secret_key(wallet_path, account_index, password).map_err(|e| {
+        if e.to_string().contains("Mac Mismatch") {
+            anyhow::anyhow!("Failed to access forc-wallet vault. Please check your password")
+        } else {
+            e
+        }
+    })?;
+    Ok(secret_key)
+}
+
+pub(crate) fn select_manual_secret_key(
+    default_signer: bool,
+    signing_key: Option<SecretKey>,
+) -> Option<SecretKey> {
+    match (default_signer, signing_key) {
+        // Note: unwrap is safe here as we already know that 'DEFAULT_PRIVATE_KEY' is a valid private key.
+        (true, None) => Some(SecretKey::from_str(DEFAULT_PRIVATE_KEY).unwrap()),
+        (true, Some(signing_key)) => {
+            println_warning("Signing key is provided while requesting to sign with a default signer. Using signing key");
+            Some(signing_key)
+        }
+        (false, None) => None,
+        (false, Some(signing_key)) => Some(signing_key),
+    }
+}
+
 /// Collect and return balances of each account in the accounts map.
 async fn collect_account_balances(
     accounts_map: &AccountsMap,
@@ -73,7 +128,7 @@ async fn collect_account_balances(
 ) -> Result<AccountBalances> {
     let accounts: Vec<_> = accounts_map
         .values()
-        .map(|addr| Wallet::from_address(addr.clone(), Some(provider.clone())))
+        .map(|addr| Wallet::from_address((*addr).into(), Some(provider.clone())))
         .collect();
 
     futures::future::try_join_all(accounts.iter().map(|acc| acc.get_balances()))
@@ -81,262 +136,202 @@ async fn collect_account_balances(
         .map_err(|e| anyhow::anyhow!("{e}"))
 }
 
-#[async_trait]
-pub trait TransactionBuilderExt<Tx> {
-    fn add_contract(&mut self, contract_id: ContractId) -> &mut Self;
-    fn add_contracts(&mut self, contract_ids: Vec<ContractId>) -> &mut Self;
-    fn add_inputs(&mut self, inputs: Vec<Input>) -> &mut Self;
-    async fn fund(
-        &mut self,
-        address: Address,
-        provider: Provider,
-        signature_witness_index: u16,
-    ) -> Result<&mut Self>;
-    async fn finalize_signed(
-        &mut self,
-        client: Provider,
-        unsigned: bool,
-        signing_key: Option<SecretKey>,
-        wallet_mode: WalletSelectionMode,
-    ) -> Result<Tx>;
+/// Format collected account balances for each asset type, including only the balance of the base asset that can be used to pay gas.
+pub fn format_base_asset_account_balances(
+    accounts_map: &AccountsMap,
+    account_balances: &AccountBalances,
+    base_asset_id: &AssetId,
+) -> Result<Vec<String>> {
+    accounts_map
+        .iter()
+        .zip(account_balances)
+        .map(|((ix, address), balance)| {
+            let base_asset_amount = balance
+                .get(&base_asset_id.to_string())
+                .copied()
+                .unwrap_or(0);
+            let raw_addr = format!("0x{address}");
+            let checksum_addr = checksum_encode(&raw_addr)?;
+            let eth_amount = base_asset_amount as f64 / 1_000_000_000.0;
+            Ok(format!("[{ix}] {checksum_addr} - {eth_amount} ETH"))
+        })
+        .collect::<Result<Vec<_>>>()
 }
 
-#[async_trait]
-impl<Tx: Buildable + field::Witnesses + Send> TransactionBuilderExt<Tx> for TransactionBuilder<Tx> {
-    fn add_contract(&mut self, contract_id: ContractId) -> &mut Self {
-        let input_index = self
-            .inputs()
-            .len()
-            .try_into()
-            .expect("limit of 256 inputs exceeded");
-        self.add_input(fuel_tx::Input::contract(
-            fuel_tx::UtxoId::new(fuel_tx::Bytes32::zeroed(), 0),
-            fuel_tx::Bytes32::zeroed(),
-            fuel_tx::Bytes32::zeroed(),
-            fuel_tx::TxPointer::new(0u32.into(), 0),
-            contract_id,
-        ))
-        .add_output(fuel_tx::Output::Contract(
-            fuel_tx::output::contract::Contract {
-                input_index,
-                balance_root: fuel_tx::Bytes32::zeroed(),
-                state_root: fuel_tx::Bytes32::zeroed(),
-            },
-        ))
-    }
-    fn add_contracts(&mut self, contract_ids: Vec<ContractId>) -> &mut Self {
-        for contract_id in contract_ids {
-            self.add_contract(contract_id);
-        }
-        self
-    }
-    fn add_inputs(&mut self, inputs: Vec<Input>) -> &mut Self {
-        for input in inputs {
-            self.add_input(input);
-        }
-        self
-    }
-    async fn fund(
-        &mut self,
-        address: Address,
-        provider: Provider,
-        signature_witness_index: u16,
-    ) -> Result<&mut Self> {
-        let asset_id = *provider.base_asset_id();
-        let wallet = Wallet::from_address(Bech32Address::from(address), Some(provider));
-
-        let amount = 1_000_000;
-        let inputs: Vec<_> = wallet
-            .get_spendable_resources(asset_id, amount)
-            .await?
-            .into_iter()
-            .map(|coin_type| match coin_type {
-                CoinType::Coin(coin) => create_coin_input(coin, signature_witness_index),
-                CoinType::Message(message) => {
-                    create_coin_message_input(message, signature_witness_index)
-                }
-            })
-            .collect();
-        let output = Output::change(wallet.address().into(), 0, asset_id);
+// TODO: Simplify the function signature once https://github.com/FuelLabs/sway/issues/6071 is closed.
+pub(crate) async fn select_account(
+    wallet_mode: &SignerSelectionMode,
+    default_sign: bool,
+    signing_key: Option<SecretKey>,
+    provider: &Provider,
+    tx_count: usize,
+) -> Result<ForcClientAccount> {
+    let chain_info = provider.chain_info().await?;
+    match wallet_mode {
+        SignerSelectionMode::ForcWallet(password) => {
+            let wallet_path = default_wallet_path();
+            check_and_create_wallet_at_default_path(&wallet_path)?;
+            // TODO: This is a very simple TUI, we should consider adding a nice TUI
+            // capabilities for selections and answer collection.
+            let accounts = collect_user_accounts(&wallet_path, password)?;
+            let account_balances = collect_account_balances(&accounts, provider).await?;
+            let base_asset_id = provider.base_asset_id();
 
-        self.add_inputs(inputs).add_output(output);
+            let total_balance = account_balances
+                .iter()
+                .flat_map(|account| account.values())
+                .sum::<u64>();
+            if total_balance == 0 {
+                let first_account = accounts
+                    .get(&0)
+                    .ok_or_else(|| anyhow::anyhow!("No account derived for this wallet"))?;
+                let target = Target::from_str(&chain_info.name).unwrap_or_default();
+                let message = if let Some(faucet_url) = target.faucet_url() {
+                    format!(
+                        "Your wallet does not have any funds to pay for the transaction.\
+                        \n\nIf you are interacting with a testnet, consider using the faucet.\
+                        \n-> {target} network faucet: {}/?address={first_account}\
+                        \nIf you are interacting with a local node, consider providing a chainConfig which funds your account.",
+                        faucet_url
+                    )
+                } else {
+                    "Your wallet does not have any funds to pay for the transaction.".to_string()
+                };
+                anyhow::bail!(message)
+            }
+            let selections =
+                format_base_asset_account_balances(&accounts, &account_balances, base_asset_id)?;
 
-        Ok(self)
-    }
-    async fn finalize_signed(
-        &mut self,
-        provider: Provider,
-        default_sign: bool,
-        signing_key: Option<SecretKey>,
-        wallet_mode: WalletSelectionMode,
-    ) -> Result<Tx> {
-        let chain_info = provider.chain_info().await?;
-        let params = chain_info.consensus_parameters;
-        let signing_key = match (wallet_mode, signing_key, default_sign) {
-            (WalletSelectionMode::ForcWallet, None, false) => {
-                // TODO: This is a very simple TUI, we should consider adding a nice TUI
-                // capabilities for selections and answer collection.
-                let wallet_path = default_wallet_path();
-                if !wallet_path.exists() {
-                    let question = format!("Could not find a wallet at {wallet_path:?}, would you like to create a new one? [y/N]: ");
-                    let accepted = ask_user_yes_no_question(&question)?;
-                    let new_options = New {
-                        force: false,
-                        cache_accounts: None,
-                    };
-                    if accepted {
-                        new_wallet_cli(&wallet_path, new_options)?;
-                        println!("Wallet created successfully.");
-                        // Derive first account for the fresh wallet we created.
-                        new_at_index_cli(&wallet_path, 0)?;
-                        println!("Account derived successfully.");
-                    } else {
-                        anyhow::bail!("Refused to create a new wallet. If you don't want to use forc-wallet, you can sign this transaction manually with --manual-signing flag.")
-                    }
-                }
-                let prompt = format!(
-                        "\nPlease provide the password of your encrypted wallet vault at {wallet_path:?}: "
-                    );
-                let password = rpassword::prompt_password(prompt)?;
-                let verification = AccountVerification::Yes(password.clone());
-                let accounts = collect_accounts_with_verification(&wallet_path, verification)
-                    .map_err(|e| {
-                        if e.to_string().contains("Mac Mismatch") {
-                            anyhow::anyhow!(
-                                "Failed to access forc-wallet vault. Please check your password"
-                            )
-                        } else {
-                            e
-                        }
-                    })?;
-                let account_balances = collect_account_balances(&accounts, &provider).await?;
-
-                let total_balance = account_balances
-                    .iter()
-                    .flat_map(|account| account.values())
-                    .sum::<u64>();
-                if total_balance == 0 {
-                    let first_account = accounts
-                        .get(&0)
-                        .ok_or_else(|| anyhow::anyhow!("No account derived for this wallet"))?;
-                    let target = Target::from_str(&chain_info.name).unwrap_or(Target::testnet());
-                    let faucet_link = format!("{}/?address={first_account}", target.faucet_url());
-                    anyhow::bail!("Your wallet does not have any funds to pay for the transaction.\
-                                      \n\nIf you are interacting with a testnet consider using the faucet.\
-                                      \n-> {target} network faucet: {faucet_link}\
-                                      \nIf you are interacting with a local node, consider providing a chainConfig which funds your account.")
-                }
-                print_account_balances(&accounts, &account_balances);
-
-                let mut account_index;
-                loop {
-                    print!("\nPlease provide the index of account to use for signing: ");
-                    std::io::stdout().flush()?;
-                    let mut input_account_index = String::new();
-                    std::io::stdin().read_line(&mut input_account_index)?;
-                    account_index = input_account_index.trim().parse::<usize>()?;
-                    if accounts.contains_key(&account_index) {
-                        break;
-                    }
-                    let options: Vec<String> = accounts.keys().map(|key| key.to_string()).collect();
-                    println_warning(&format!(
-                        "\"{}\" is not a valid account.\nPlease choose a valid option from {}",
-                        account_index,
-                        options.join(","),
-                    ));
-                }
+            let mut account_index;
+            loop {
+                account_index = Select::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Wallet account")
+                    .max_length(5)
+                    .items(&selections[..])
+                    .default(0)
+                    .interact()?;
 
-                let secret_key = derive_secret_key(&wallet_path, account_index, &password)
-                    .map_err(|e| {
-                        if e.to_string().contains("Mac Mismatch") {
-                            anyhow::anyhow!(
-                                "Failed to access forc-wallet vault. Please check your password"
-                            )
-                        } else {
-                            e
-                        }
-                    })?;
-
-                // TODO: Do this via forc-wallet once the functionality is exposed.
-                let public_key = PublicKey::from(&secret_key);
-                let hashed = public_key.hash();
-                let bech32 = Bech32Address::new(FUEL_BECH32_HRP, hashed);
-                let question = format!(
-                    "Do you agree to sign this transaction with {}? [y/N]: ",
-                    bech32
-                );
-                let accepted = ask_user_yes_no_question(&question)?;
-                if !accepted {
-                    anyhow::bail!("User refused to sign");
+                if accounts.contains_key(&account_index) {
+                    break;
                 }
-
-                Some(secret_key)
-            }
-            (WalletSelectionMode::ForcWallet, Some(key), _) => {
-                println_warning("Signing key is provided while requesting to sign with forc-wallet or with default signer. Using signing key");
-                Some(key)
+                let options: Vec<String> = accounts
+                    .keys()
+                    .map(|key| {
+                        let raw_addr = format!("0x{key}");
+                        let checksum_addr = checksum_encode(&raw_addr)?;
+                        Ok(checksum_addr)
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                println_warning(&format!(
+                    "\"{}\" is not a valid account.\nPlease choose a valid option from {}",
+                    account_index,
+                    options.join(","),
+                ));
             }
-            (WalletSelectionMode::Manual, None, false) => None,
-            (WalletSelectionMode::Manual, Some(key), false) => Some(key),
-            (_, None, true) => {
-                // Generate a `SecretKey` to sign this transaction from a default private key used
-                // by fuel-core.
-                let secret_key = SecretKey::from_str(DEFAULT_PRIVATE_KEY)?;
-                Some(secret_key)
-            }
-            (WalletSelectionMode::Manual, Some(key), true) => {
-                println_warning("Signing key is provided while requesting to sign with a default signer. Using signing key");
-                Some(key)
-            }
-        };
-        // Get the address
-        let address = if let Some(key) = signing_key {
-            Address::from(*key.public_key().hash())
-        } else {
-            Address::from(prompt_address()?)
-        };
 
-        // Insert dummy witness for signature
-        let signature_witness_index = self.witnesses().len().try_into()?;
-        self.add_witness(Witness::default());
-
-        // Add input coin and output change
-        self.fund(
-                address,
-                provider,
-                signature_witness_index,
-            )
-            .await.map_err(|e| if e.to_string().contains("not enough coins to fit the target") {
-                anyhow::anyhow!("Deployment failed due to insufficient funds. Please be sure to have enough coins to pay for deployment transaction.")
-            } else {
-                e
-            })?;
-
-        let mut tx = self.finalize_without_signature_inner();
-
-        let signature = if let Some(signing_key) = signing_key {
-            let message = Message::from_bytes(*tx.id(&params.chain_id()));
-            Signature::sign(&signing_key, &message)
-        } else {
-            prompt_signature(tx.id(&params.chain_id()))?
-        };
+            let secret_key = secret_key_from_forc_wallet(&wallet_path, account_index, password)?;
 
-        let witness = Witness::from(signature.as_ref());
-        tx.replace_witness(signature_witness_index, witness);
-        tx.precompute(&params.chain_id())
-            .map_err(anyhow::Error::msg)?;
+            // TODO: Do this via forc-wallet once the functionality is exposed.
+            // TODO: calculate the number of transactions to sign and ask the user to confirm.
+            let question = format!(
+                "Do you agree to sign {tx_count} transaction{}?",
+                if tx_count > 1 { "s" } else { "" }
+            );
+            let accepted = ask_user_yes_no_question(&question)?;
+            if !accepted {
+                anyhow::bail!("User refused to sign");
+            }
 
-        Ok(tx)
+            let wallet = WalletUnlocked::new_from_private_key(secret_key, Some(provider.clone()));
+            Ok(ForcClientAccount::Wallet(wallet))
+        }
+        SignerSelectionMode::Manual => {
+            let secret_key = select_manual_secret_key(default_sign, signing_key)
+                .ok_or_else(|| anyhow::anyhow!("missing manual secret key"))?;
+            let wallet = WalletUnlocked::new_from_private_key(secret_key, Some(provider.clone()));
+            Ok(ForcClientAccount::Wallet(wallet))
+        }
+        SignerSelectionMode::AwsSigner(arn) => {
+            let aws_config = AwsConfig::from_env().await;
+            let aws_client = AwsClient::new(aws_config);
+            let aws_signer = AwsSigner::new(aws_client, arn.clone(), provider.clone()).await?;
+
+            let account = ForcClientAccount::KmsSigner(aws_signer);
+            Ok(account)
+        }
     }
 }
 
-pub trait TransactionExt {
-    fn replace_witness(&mut self, witness_index: u16, witness: Witness) -> &mut Self;
+pub async fn update_proxy_contract_target(
+    account: &ForcClientAccount,
+    proxy_contract_id: ContractId,
+    new_target: ContractId,
+) -> Result<CallResponse<()>> {
+    abigen!(Contract(name = "ProxyContract", abi = "{\"programType\":\"contract\",\"specVersion\":\"1\",\"encodingVersion\":\"1\",\"concreteTypes\":[{\"type\":\"()\",\"concreteTypeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"type\":\"enum standards::src5::AccessError\",\"concreteTypeId\":\"3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d\",\"metadataTypeId\":1},{\"type\":\"enum standards::src5::State\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"metadataTypeId\":2},{\"type\":\"enum std::option::Option<struct std::contract_id::ContractId>\",\"concreteTypeId\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"metadataTypeId\":4,\"typeArguments\":[\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\"]},{\"type\":\"enum sway_libs::ownership::errors::InitializationError\",\"concreteTypeId\":\"1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893\",\"metadataTypeId\":5},{\"type\":\"enum sway_libs::upgradability::errors::SetProxyOwnerError\",\"concreteTypeId\":\"3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74\",\"metadataTypeId\":6},{\"type\":\"str\",\"concreteTypeId\":\"8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a\"},{\"type\":\"struct std::contract_id::ContractId\",\"concreteTypeId\":\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\",\"metadataTypeId\":9},{\"type\":\"struct sway_libs::upgradability::events::ProxyOwnerSet\",\"concreteTypeId\":\"96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247\",\"metadataTypeId\":10},{\"type\":\"struct sway_libs::upgradability::events::ProxyTargetSet\",\"concreteTypeId\":\"1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8\",\"metadataTypeId\":11}],\"metadataTypes\":[{\"type\":\"b256\",\"metadataTypeId\":0},{\"type\":\"enum standards::src5::AccessError\",\"metadataTypeId\":1,\"components\":[{\"name\":\"NotOwner\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum standards::src5::State\",\"metadataTypeId\":2,\"components\":[{\"name\":\"Uninitialized\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"name\":\"Initialized\",\"typeId\":3},{\"name\":\"Revoked\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum std::identity::Identity\",\"metadataTypeId\":3,\"components\":[{\"name\":\"Address\",\"typeId\":8},{\"name\":\"ContractId\",\"typeId\":9}]},{\"type\":\"enum std::option::Option\",\"metadataTypeId\":4,\"components\":[{\"name\":\"None\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"name\":\"Some\",\"typeId\":7}],\"typeParameters\":[7]},{\"type\":\"enum sway_libs::ownership::errors::InitializationError\",\"metadataTypeId\":5,\"components\":[{\"name\":\"CannotReinitialized\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum sway_libs::upgradability::errors::SetProxyOwnerError\",\"metadataTypeId\":6,\"components\":[{\"name\":\"CannotUninitialize\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"generic T\",\"metadataTypeId\":7},{\"type\":\"struct std::address::Address\",\"metadataTypeId\":8,\"components\":[{\"name\":\"bits\",\"typeId\":0}]},{\"type\":\"struct std::contract_id::ContractId\",\"metadataTypeId\":9,\"components\":[{\"name\":\"bits\",\"typeId\":0}]},{\"type\":\"struct sway_libs::upgradability::events::ProxyOwnerSet\",\"metadataTypeId\":10,\"components\":[{\"name\":\"new_proxy_owner\",\"typeId\":2}]},{\"type\":\"struct sway_libs::upgradability::events::ProxyTargetSet\",\"metadataTypeId\":11,\"components\":[{\"name\":\"new_target\",\"typeId\":9}]}],\"functions\":[{\"inputs\":[],\"name\":\"proxy_target\",\"output\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Returns the target contract of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Returns\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * [Option<ContractId>] - The new proxy contract to which all fallback calls will be passed or `None`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\"]}]},{\"inputs\":[{\"name\":\"new_target\",\"concreteTypeId\":\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\"}],\"name\":\"set_proxy_target\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Change the target contract of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can only be called by the `proxy_owner`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Arguments\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * `new_target`: [ContractId] - The new proxy contract to which all fallback calls will be passed.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When not called by `proxy_owner`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Write: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\",\"write\"]}]},{\"inputs\":[],\"name\":\"proxy_owner\",\"output\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Returns the owner of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Returns\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * [State] - Represents the state of ownership for this contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\"]}]},{\"inputs\":[],\"name\":\"initialize_proxy\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Initializes the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method sets the storage values using the values of the configurable constants `INITIAL_TARGET` and `INITIAL_OWNER`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This then allows methods that write to storage to be called.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can only be called once.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When `storage::SRC14.proxy_owner` is not [State::Uninitialized].\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Writes: `2`\"]},{\"name\":\"storage\",\"arguments\":[\"write\"]}]},{\"inputs\":[{\"name\":\"new_proxy_owner\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\"}],\"name\":\"set_proxy_owner\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Changes proxy ownership to the passed State.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can be used to transfer ownership between Identities or to revoke ownership.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Arguments\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * `new_proxy_owner`: [State] - The new state of the proxy ownership.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When the sender is not the current proxy owner.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When the new state of the proxy ownership is [State::Uninitialized].\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Writes: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"write\"]}]}],\"loggedTypes\":[{\"logId\":\"4571204900286667806\",\"concreteTypeId\":\"3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d\"},{\"logId\":\"2151606668983994881\",\"concreteTypeId\":\"1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8\"},{\"logId\":\"2161305517876418151\",\"concreteTypeId\":\"1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893\"},{\"logId\":\"4354576968059844266\",\"concreteTypeId\":\"3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74\"},{\"logId\":\"10870989709723147660\",\"concreteTypeId\":\"96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247\"},{\"logId\":\"10098701174489624218\",\"concreteTypeId\":\"8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a\"}],\"messagesTypes\":[],\"configurables\":[{\"name\":\"INITIAL_TARGET\",\"concreteTypeId\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"offset\":13368},{\"name\":\"INITIAL_OWNER\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"offset\":13320}]}",));
+
+    let proxy_contract = ProxyContract::new(proxy_contract_id, account.clone());
+
+    let result = proxy_contract
+        .methods()
+        .set_proxy_target(new_target)
+        .call()
+        .await?;
+    println_action_green(
+        "Updated",
+        &format!("proxy contract target to 0x{new_target}"),
+    );
+    Ok(result)
 }
 
-impl<T: field::Witnesses> TransactionExt for T {
-    fn replace_witness(&mut self, index: u16, witness: Witness) -> &mut Self {
-        self.witnesses_mut()[index as usize] = witness;
-        self
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use fuels::types::bech32::Bech32Address;
+    use std::collections::{BTreeMap, HashMap};
+
+    #[test]
+    fn test_format_base_asset_account_balances() {
+        let mut accounts_map: AccountsMap = BTreeMap::new();
+
+        let address1: fuel_tx::Address = Bech32Address::from_str(
+            "fuel1dved7k25uxadatl7l5kql309jnw07dcn4t3a6x9hm9nxyjcpqqns50p7n2",
+        )
+        .expect("address1")
+        .into();
+
+        let address2: fuel_tx::Address = Bech32Address::from_str(
+            "fuel1x9f3ysyk7fmey5ac23s2p4rwg4gjye2kke3nu3pvrs5p4qc4m4qqwx56k3",
+        )
+        .expect("address2")
+        .into();
+
+        let base_asset_id = AssetId::zeroed();
+
+        accounts_map.insert(0, address1);
+        accounts_map.insert(1, address2);
+
+        let mut account_balances: AccountBalances = Vec::new();
+        let mut balance1 = HashMap::new();
+        balance1.insert(base_asset_id.to_string(), 1_500_000_000);
+        balance1.insert("other_asset".to_string(), 2_000_000_000);
+        account_balances.push(balance1);
+
+        let mut balance2 = HashMap::new();
+        balance2.insert("other_asset".to_string(), 3_000_000_000);
+        account_balances.push(balance2);
+
+        let address1_expected =
+            "0x6B32DF5954e1BaDEAFFEFD2c0fc5E594dcff3713aaE3Dd18B7d966624B010027";
+        let address2_expected =
+            "0x3153124096f2779253B85460a0D46e4551226556b6633E442c1C281a8315dd40";
+        let expected = vec![
+            format!("[0] {address1_expected} - 1.5 ETH"),
+            format!("[1] {address2_expected} - 0 ETH"),
+        ];
+
+        let result =
+            format_base_asset_account_balances(&accounts_map, &account_balances, &base_asset_id)
+                .unwrap();
+        assert_eq!(result, expected);
     }
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/.gitignore b/forc-plugins/forc-client/test/data/big_contract/.gitignore
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/.gitignore
rename to forc-plugins/forc-client/test/data/big_contract/.gitignore
diff --git a/forc-plugins/forc-client/test/data/big_contract/Forc.toml b/forc-plugins/forc-client/test/data/big_contract/Forc.toml
new file mode 100644
index 00000000000..539c466315e
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/big_contract/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "big_contract"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std/" }
diff --git a/forc-plugins/forc-client/test/data/big_contract/big_contract-abi.json b/forc-plugins/forc-client/test/data/big_contract/big_contract-abi.json
new file mode 100644
index 00000000000..0fa70821c2c
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/big_contract/big_contract-abi.json
@@ -0,0 +1,502 @@
+{
+  "programType": "contract",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
+    {
+      "type": "()",
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    },
+    {
+      "type": "(bool, u64)",
+      "concreteTypeId": "c998ca9a5f221fe7b5c66ae70c8a9562b86d964408b00d17f883c906bc1fe4be",
+      "metadataTypeId": 0
+    },
+    {
+      "type": "[bool; 3]",
+      "concreteTypeId": "4926d35d1a5157936b0a29bc126b8aace6d911209a5c130e9b716b0c73643ea6",
+      "metadataTypeId": 5
+    },
+    {
+      "type": "[enum Location; 2]",
+      "concreteTypeId": "fb7957f865b6c8ee87b25381a2861c279107dc2fff0e6bd25586198dc65470d0",
+      "metadataTypeId": 1
+    },
+    {
+      "type": "[struct SimpleStruct; 3]",
+      "concreteTypeId": "96dffad5a46b9db38f00f4431235e7e9bab7a85e8ee9a514aa81063d429ceb7a",
+      "metadataTypeId": 7
+    },
+    {
+      "type": "[u64; 3]",
+      "concreteTypeId": "776fb5a3824169d6736138565fdc20aad684d9111266a5ff6d5c675280b7e199",
+      "metadataTypeId": 6
+    },
+    {
+      "type": "b256",
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+    },
+    {
+      "type": "bool",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    },
+    {
+      "type": "enum Location",
+      "concreteTypeId": "6966f221767e2951c5d68ba5e81e897449375a9f51f5e4c9e3b65f1dd7defabb",
+      "metadataTypeId": 9
+    },
+    {
+      "type": "str[4]",
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a"
+    },
+    {
+      "type": "struct Person",
+      "concreteTypeId": "a6b272bcf0f572840e2cc1241bdcf8d42db51eeb1aead750c8e608160f83f926",
+      "metadataTypeId": 11
+    },
+    {
+      "type": "struct SimpleStruct",
+      "concreteTypeId": "75f7f7a06026cab5d7a70984d1fde56001e83505e3a091ff9722b92d7f56d8be",
+      "metadataTypeId": 12
+    },
+    {
+      "type": "u16",
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+    },
+    {
+      "type": "u256",
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+    },
+    {
+      "type": "u32",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+    },
+    {
+      "type": "u64",
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    },
+    {
+      "type": "u8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "metadataTypes": [
+    {
+      "type": "(_, _)",
+      "metadataTypeId": 0,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ]
+    },
+    {
+      "type": "[_; 2]",
+      "metadataTypeId": 1,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": 9
+        }
+      ]
+    },
+    {
+      "type": "[_; 2]",
+      "metadataTypeId": 2,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": 8
+        }
+      ]
+    },
+    {
+      "type": "[_; 2]",
+      "metadataTypeId": 3,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": 12
+        }
+      ]
+    },
+    {
+      "type": "[_; 2]",
+      "metadataTypeId": 4,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ]
+    },
+    {
+      "type": "[_; 3]",
+      "metadataTypeId": 5,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        }
+      ]
+    },
+    {
+      "type": "[_; 3]",
+      "metadataTypeId": 6,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ]
+    },
+    {
+      "type": "[_; 3]",
+      "metadataTypeId": 7,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": 12
+        }
+      ]
+    },
+    {
+      "type": "enum Color",
+      "metadataTypeId": 8,
+      "components": [
+        {
+          "name": "Red",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        },
+        {
+          "name": "Blue",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ]
+    },
+    {
+      "type": "enum Location",
+      "metadataTypeId": 9,
+      "components": [
+        {
+          "name": "Earth",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        },
+        {
+          "name": "Mars",
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+        },
+        {
+          "name": "SimpleJupiter",
+          "typeId": 8
+        },
+        {
+          "name": "Jupiter",
+          "typeId": 2
+        },
+        {
+          "name": "SimplePluto",
+          "typeId": 12
+        },
+        {
+          "name": "Pluto",
+          "typeId": 3
+        }
+      ]
+    },
+    {
+      "type": "str",
+      "metadataTypeId": 10
+    },
+    {
+      "type": "struct Person",
+      "metadataTypeId": 11,
+      "components": [
+        {
+          "name": "name",
+          "typeId": 10
+        },
+        {
+          "name": "age",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        },
+        {
+          "name": "alive",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "location",
+          "typeId": 9
+        },
+        {
+          "name": "some_tuple",
+          "typeId": 0
+        },
+        {
+          "name": "some_array",
+          "typeId": 4
+        },
+        {
+          "name": "some_b256",
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+        }
+      ]
+    },
+    {
+      "type": "struct SimpleStruct",
+      "metadataTypeId": 12,
+      "components": [
+        {
+          "name": "a",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "b",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ]
+    }
+  ],
+  "functions": [
+    {
+      "inputs": [
+        {
+          "name": "aoe",
+          "concreteTypeId": "fb7957f865b6c8ee87b25381a2861c279107dc2fff0e6bd25586198dc65470d0"
+        }
+      ],
+      "name": "array_of_enum_input_output",
+      "output": "fb7957f865b6c8ee87b25381a2861c279107dc2fff0e6bd25586198dc65470d0",
+      "attributes": null
+    },
+    {
+      "inputs": [],
+      "name": "assert_configurables",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "attributes": null
+    },
+    {
+      "inputs": [
+        {
+          "name": "loc",
+          "concreteTypeId": "6966f221767e2951c5d68ba5e81e897449375a9f51f5e4c9e3b65f1dd7defabb"
+        }
+      ],
+      "name": "enum_input_output",
+      "output": "6966f221767e2951c5d68ba5e81e897449375a9f51f5e4c9e3b65f1dd7defabb",
+      "attributes": null
+    },
+    {
+      "inputs": [
+        {
+          "name": "index",
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ],
+      "name": "get_storage_location",
+      "output": "6966f221767e2951c5d68ba5e81e897449375a9f51f5e4c9e3b65f1dd7defabb",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "index",
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ],
+      "name": "get_storage_simple",
+      "output": "75f7f7a06026cab5d7a70984d1fde56001e83505e3a091ff9722b92d7f56d8be",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "index",
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ],
+      "name": "get_storage_u16",
+      "output": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [],
+      "name": "large_blob",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "attributes": null
+    },
+    {
+      "inputs": [
+        {
+          "name": "value",
+          "concreteTypeId": "6966f221767e2951c5d68ba5e81e897449375a9f51f5e4c9e3b65f1dd7defabb"
+        }
+      ],
+      "name": "push_storage_location",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read",
+            "write"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "value",
+          "concreteTypeId": "75f7f7a06026cab5d7a70984d1fde56001e83505e3a091ff9722b92d7f56d8be"
+        }
+      ],
+      "name": "push_storage_simple",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read",
+            "write"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "value",
+          "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+        }
+      ],
+      "name": "push_storage_u16",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read",
+            "write"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "person",
+          "concreteTypeId": "a6b272bcf0f572840e2cc1241bdcf8d42db51eeb1aead750c8e608160f83f926"
+        }
+      ],
+      "name": "struct_input_output",
+      "output": "a6b272bcf0f572840e2cc1241bdcf8d42db51eeb1aead750c8e608160f83f926",
+      "attributes": null
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "configurables": [
+    {
+      "name": "BOOL",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "offset": 392688
+    },
+    {
+      "name": "U8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "offset": 392832
+    },
+    {
+      "name": "U16",
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "offset": 392776
+    },
+    {
+      "name": "U32",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "offset": 392816
+    },
+    {
+      "name": "U64",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "offset": 392824
+    },
+    {
+      "name": "U256",
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "offset": 392784
+    },
+    {
+      "name": "B256",
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "offset": 392656
+    },
+    {
+      "name": "CONFIGURABLE_STRUCT",
+      "concreteTypeId": "75f7f7a06026cab5d7a70984d1fde56001e83505e3a091ff9722b92d7f56d8be",
+      "offset": 392736
+    },
+    {
+      "name": "CONFIGURABLE_ENUM",
+      "concreteTypeId": "6966f221767e2951c5d68ba5e81e897449375a9f51f5e4c9e3b65f1dd7defabb",
+      "offset": 392696
+    },
+    {
+      "name": "ARRAY_BOOL",
+      "concreteTypeId": "4926d35d1a5157936b0a29bc126b8aace6d911209a5c130e9b716b0c73643ea6",
+      "offset": 392512
+    },
+    {
+      "name": "ARRAY_U64",
+      "concreteTypeId": "776fb5a3824169d6736138565fdc20aad684d9111266a5ff6d5c675280b7e199",
+      "offset": 392632
+    },
+    {
+      "name": "ARRAY_LOCATION",
+      "concreteTypeId": "fb7957f865b6c8ee87b25381a2861c279107dc2fff0e6bd25586198dc65470d0",
+      "offset": 392520
+    },
+    {
+      "name": "ARRAY_SIMPLE_STRUCT",
+      "concreteTypeId": "96dffad5a46b9db38f00f4431235e7e9bab7a85e8ee9a514aa81063d429ceb7a",
+      "offset": 392600
+    },
+    {
+      "name": "TUPLE_BOOL_U64",
+      "concreteTypeId": "c998ca9a5f221fe7b5c66ae70c8a9562b86d964408b00d17f883c906bc1fe4be",
+      "offset": 392760
+    },
+    {
+      "name": "STR_4",
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
+      "offset": 392752
+    }
+  ]
+}
\ No newline at end of file
diff --git a/forc-plugins/forc-client/test/data/big_contract/src/main.sw b/forc-plugins/forc-client/test/data/big_contract/src/main.sw
new file mode 100644
index 00000000000..83eb21e2d1f
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/big_contract/src/main.sw
@@ -0,0 +1,210 @@
+contract;
+
+use std::storage::storage_vec::*;
+use std::hash::*;
+
+abi MyContract {
+    fn large_blob() -> bool;
+    
+    fn enum_input_output(loc: Location) -> Location;
+    
+    fn struct_input_output(person: Person) -> Person;
+    
+    fn array_of_enum_input_output(aoe: [Location; 2]) -> [Location; 2];
+    
+    #[storage(read, write)]
+    fn push_storage_u16(value: u16);
+
+    #[storage(read)]
+    fn get_storage_u16(index: u64) -> u16;
+
+    #[storage(read, write)]
+    fn push_storage_simple(value: SimpleStruct);
+
+    #[storage(read)]
+    fn get_storage_simple(index: u64) -> SimpleStruct;
+
+    #[storage(read, write)]
+    fn push_storage_location(value: Location);
+
+    #[storage(read)]
+    fn get_storage_location(index: u64) -> Location;
+
+    fn assert_configurables() -> bool;
+}
+
+enum Location {
+    Earth: u64,
+    Mars: (),
+    SimpleJupiter: Color,
+    Jupiter: [Color; 2],
+    SimplePluto: SimpleStruct,
+    Pluto: [SimpleStruct; 2],
+}
+
+enum Color {
+    Red: (),
+    Blue: u64,
+}
+
+struct Person {
+    name: str,
+    age: u64,
+    alive: bool,
+    location: Location,
+    some_tuple: (bool, u64),
+    some_array: [u64; 2],
+    some_b256: b256,
+}
+
+struct SimpleStruct {
+    a: bool,
+    b: u64,
+}
+
+storage {
+    my_vec: StorageVec<u16> = StorageVec {},
+    my_simple_vec: StorageVec<SimpleStruct> = StorageVec {},
+    my_location_vec: StorageVec<Location> = StorageVec {},
+}
+
+configurable {
+    BOOL: bool = true,
+    U8: u8 = 1,
+    U16: u16 = 2,
+    U32: u32 = 3,
+    U64: u32 = 4,
+    U256: u256 = 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu256,
+    B256: b256 = 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,
+    CONFIGURABLE_STRUCT: SimpleStruct = SimpleStruct { a: true, b: 5 },
+    CONFIGURABLE_ENUM: Location = Location::Earth(1),
+    ARRAY_BOOL: [bool; 3] = [true, false, true],
+    ARRAY_U64: [u64; 3] = [9, 8, 7],
+    ARRAY_LOCATION: [Location; 2] = [Location::Earth(10), Location::Mars],
+    ARRAY_SIMPLE_STRUCT: [SimpleStruct; 3] = [ SimpleStruct { a: true, b: 5}, SimpleStruct { a: false, b: 0 }, SimpleStruct { a: true, b: u64::max() }],
+    TUPLE_BOOL_U64: (bool, u64) = (true, 11),
+    STR_4: str[4] = __to_str_array("abcd"),
+}
+
+impl core::ops::Eq for Color {
+    fn eq(self, other: Color) -> bool {
+        match (self, other) {
+            (Color::Red, Color::Red) => true,
+            (Color::Blue(inner1), Color::Blue(inner2)) => inner1 == inner2,
+            _ => false,
+        }
+    }
+}
+
+impl core::ops::Eq for SimpleStruct {
+    fn eq(self, other: SimpleStruct) -> bool {
+        self.a == other.a && self.b == other.b
+    }
+}
+
+impl core::ops::Eq for Location {
+    fn eq(self, other: Location) -> bool {
+        match (self, other) {
+            (Location::Earth(inner1), Location::Earth(inner2)) => inner1 == inner2,
+            (Location::Mars, Location::Mars) => true,
+            (Location::SimpleJupiter(inner1), Location::SimpleJupiter(inner2)) => inner1 == inner2,
+            (Location::Jupiter(inner1), Location::Jupiter(inner2)) => (inner1[0] == inner2[0] && inner1[1] == inner2[1]),
+            (Location::SimplePluto(inner1), Location::SimplePluto(inner2)) => inner1 == inner2,
+            (Location::Pluto(inner1), Location::Pluto(inner2)) => (inner1[0] == inner2[0] && inner1[1] == inner2[1]),
+            _ => false,
+        }
+    }
+}
+
+impl MyContract for Contract {
+    fn large_blob() -> bool {
+        asm() {
+            blob i91000;
+        }
+        true
+    }
+
+    fn enum_input_output(loc: Location) -> Location {
+        loc
+    }
+
+    fn struct_input_output(person: Person) -> Person {
+        person
+    }
+
+    fn array_of_enum_input_output(aoe: [Location; 2]) -> [Location; 2] {
+        aoe
+    }
+
+    #[storage(read, write)]
+    fn push_storage_u16(value: u16) {
+        storage.my_vec.push(value);
+    }
+
+    #[storage(read)]
+    fn get_storage_u16(index: u64) -> u16 {
+        storage.my_vec.get(index).unwrap().read()
+    }
+
+    #[storage(read, write)]
+    fn push_storage_simple(value: SimpleStruct) {
+        storage.my_simple_vec.push(value);
+    }
+
+    #[storage(read)]
+    fn get_storage_simple(index: u64) -> SimpleStruct {
+        storage.my_simple_vec.get(index).unwrap().read()
+    }
+    
+    #[storage(read, write)]
+    fn push_storage_location(value: Location) {
+        storage.my_location_vec.push(value);
+    }
+
+    #[storage(read)]
+    fn get_storage_location(index: u64) -> Location {
+        storage.my_location_vec.get(index).unwrap().read()
+    }
+
+    fn assert_configurables() -> bool {
+        assert(BOOL == true);
+        assert(U8 == 1);
+        assert(U16 == 2);
+        assert(U32 == 3);
+        assert(U64 == 4);
+        assert(U256 == 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu256);
+        assert(B256 == 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB);
+        assert(CONFIGURABLE_STRUCT.a == true);
+        assert(CONFIGURABLE_STRUCT.b == 5);
+        assert(CONFIGURABLE_ENUM == Location::Earth(1));
+        assert(ARRAY_BOOL[0] == true);
+        assert(ARRAY_BOOL[1] == false);
+        assert(ARRAY_BOOL[2] == true);
+        assert(ARRAY_U64[0] == 9);
+        assert(ARRAY_U64[1] == 8);
+        assert(ARRAY_U64[2] == 7);
+        assert(ARRAY_LOCATION[0] == Location::Earth(10));
+        assert(ARRAY_LOCATION[1] == Location::Mars);
+        assert(ARRAY_SIMPLE_STRUCT[0].a == true);
+        assert(ARRAY_SIMPLE_STRUCT[0].b == 5);
+        assert(ARRAY_SIMPLE_STRUCT[1].a == false);
+        assert(ARRAY_SIMPLE_STRUCT[1].b == 0);
+        assert(ARRAY_SIMPLE_STRUCT[2].a == true);
+        assert(ARRAY_SIMPLE_STRUCT[2].b == u64::max());
+        assert(ARRAY_LOCATION[1] == Location::Mars);
+        assert(ARRAY_LOCATION[1] == Location::Mars);
+        assert(TUPLE_BOOL_U64.0 == true);
+        assert(TUPLE_BOOL_U64.1 == 11);
+        assert(sha256_str_array(STR_4) == sha256("abcd"));
+
+        // Assert address do not change
+        let addr_1 = asm(addr: __addr_of(&BOOL)) {
+            addr: u64
+        };
+        let addr_2 = asm(addr: __addr_of(&BOOL)) {
+            addr: u64
+        };
+        assert(addr_1 == addr_2);
+        true
+    }
+}
diff --git a/forc-plugins/forc-client/test/data/contract_with_dep/Forc.toml b/forc-plugins/forc-client/test/data/contract_with_dep/Forc.toml
index 45be87cb3b6..4d1d6e8308b 100644
--- a/forc-plugins/forc-client/test/data/contract_with_dep/Forc.toml
+++ b/forc-plugins/forc-client/test/data/contract_with_dep/Forc.toml
@@ -6,7 +6,7 @@ license = "Apache-2.0"
 name = "contract_with_dep"
 
 [dependencies]
-std = { path = "../../../../../../../../sway-lib-std/" }
+std = { path = "../../../../../sway-lib-std/" }
 
 [contract-dependencies]
 standalone_contract = { path = "../standalone_contract", salt = "0x0000000000000000000000000000000000000000000000000000000000000001" }
diff --git a/forc-plugins/forc-client/test/data/contract_with_dep_with_salt_conflict/Forc.toml b/forc-plugins/forc-client/test/data/contract_with_dep_with_salt_conflict/Forc.toml
index 4123009928a..fe10c17663d 100644
--- a/forc-plugins/forc-client/test/data/contract_with_dep_with_salt_conflict/Forc.toml
+++ b/forc-plugins/forc-client/test/data/contract_with_dep_with_salt_conflict/Forc.toml
@@ -6,7 +6,7 @@ license = "Apache-2.0"
 name = "contract_with_dep_with_salt_conflict"
 
 [dependencies]
-std = { path = "../../../../../../../../sway-lib-std/" }
+std = { path = "../../../../../sway-lib-std/" }
 
 [contract-dependencies]
 contract_with_dep = { path = "../contract_with_dep" }
diff --git a/forc-plugins/forc-client/test/data/deployed_predicate/.gitignore b/forc-plugins/forc-client/test/data/deployed_predicate/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_predicate/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/forc-plugins/forc-client/test/data/deployed_predicate/Forc.lock b/forc-plugins/forc-client/test/data/deployed_predicate/Forc.lock
new file mode 100644
index 00000000000..2be3d70a3ca
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_predicate/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-661979F06117CBCE"
+
+[[package]]
+name = "deployed_predicate"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-661979F06117CBCE"
+dependencies = ["core"]
diff --git a/forc-plugins/forc-client/test/data/deployed_predicate/Forc.toml b/forc-plugins/forc-client/test/data/deployed_predicate/Forc.toml
new file mode 100644
index 00000000000..68b7cb9dff1
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_predicate/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "deployed_predicate"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std/" }
diff --git a/forc-plugins/forc-client/test/data/deployed_predicate/deployed_predicate-abi.json b/forc-plugins/forc-client/test/data/deployed_predicate/deployed_predicate-abi.json
new file mode 100644
index 00000000000..f38d1dbedd6
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_predicate/deployed_predicate-abi.json
@@ -0,0 +1,128 @@
+{
+  "programType": "predicate",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
+    {
+      "type": "bool",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    },
+    {
+      "type": "enum EnumWithGeneric<bool>",
+      "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
+      "metadataTypeId": 1,
+      "typeArguments": [
+        "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+      ]
+    },
+    {
+      "type": "struct StructWithGeneric<u8>",
+      "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
+      "metadataTypeId": 3,
+      "typeArguments": [
+        "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+      ]
+    },
+    {
+      "type": "u8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "metadataTypes": [
+    {
+      "type": "()",
+      "metadataTypeId": 0
+    },
+    {
+      "type": "enum EnumWithGeneric",
+      "metadataTypeId": 1,
+      "components": [
+        {
+          "name": "VariantOne",
+          "typeId": 2
+        },
+        {
+          "name": "VariantTwo",
+          "typeId": 0
+        }
+      ],
+      "typeParameters": [
+        2
+      ]
+    },
+    {
+      "type": "generic D",
+      "metadataTypeId": 2
+    },
+    {
+      "type": "struct StructWithGeneric",
+      "metadataTypeId": 3,
+      "components": [
+        {
+          "name": "field_1",
+          "typeId": 2
+        },
+        {
+          "name": "field_2",
+          "typeId": 4
+        }
+      ],
+      "typeParameters": [
+        2
+      ]
+    },
+    {
+      "type": "u64",
+      "metadataTypeId": 4
+    }
+  ],
+  "functions": [
+    {
+      "inputs": [
+        {
+          "name": "switch",
+          "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "u_8",
+          "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        },
+        {
+          "name": "some_struct",
+          "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075"
+        },
+        {
+          "name": "some_enum",
+          "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272"
+        }
+      ],
+      "name": "main",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "attributes": null
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "configurables": [
+    {
+      "name": "BOOL",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "offset": 1896
+    },
+    {
+      "name": "U8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "offset": 1936
+    },
+    {
+      "name": "STRUCT",
+      "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
+      "offset": 1920
+    },
+    {
+      "name": "ENUM",
+      "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
+      "offset": 1904
+    }
+  ]
+}
\ No newline at end of file
diff --git a/forc-plugins/forc-client/test/data/deployed_predicate/src/main.sw b/forc-plugins/forc-client/test/data/deployed_predicate/src/main.sw
new file mode 100644
index 00000000000..f33b61faf40
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_predicate/src/main.sw
@@ -0,0 +1,53 @@
+predicate;
+
+#[allow(dead_code)]
+enum EnumWithGeneric<D> {
+    VariantOne: D,
+    VariantTwo: (),
+}
+
+struct StructWithGeneric<D> {
+    field_1: D,
+    field_2: u64,
+}
+
+impl<D> Eq for EnumWithGeneric<D> 
+where
+    D: Eq,
+{
+    fn eq(self, other: Self) -> bool {
+        match (self, other) {
+            (EnumWithGeneric::VariantOne(d1), EnumWithGeneric::VariantOne(d2)) => d1 == d2,
+            (EnumWithGeneric::VariantTwo, EnumWithGeneric::VariantTwo) => true,
+            _ => false,
+        }
+    }
+}
+
+impl<D> Eq for StructWithGeneric<D>
+where
+    D: Eq,
+{
+    fn eq(self, other: Self) -> bool {
+        self.field_1 == other.field_1 && self.field_2 == other.field_2
+    }
+}
+
+configurable {
+    BOOL: bool = true,
+    U8: u8 = 8,
+    STRUCT: StructWithGeneric<u8> = StructWithGeneric {
+        field_1: 8,
+        field_2: 16,
+    },
+    ENUM: EnumWithGeneric<bool> = EnumWithGeneric::VariantOne(true),
+}
+
+fn main(
+    switch: bool,
+    u_8: u8,
+    some_struct: StructWithGeneric<u8>,
+    some_enum: EnumWithGeneric<bool>,
+) -> bool {
+    switch == BOOL && u_8 == U8 && some_struct == STRUCT && some_enum == ENUM
+}
diff --git a/forc-plugins/forc-client/test/data/deployed_script/.gitignore b/forc-plugins/forc-client/test/data/deployed_script/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_script/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/forc-plugins/forc-client/test/data/deployed_script/Forc.toml b/forc-plugins/forc-client/test/data/deployed_script/Forc.toml
new file mode 100644
index 00000000000..3eb3cdf653b
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_script/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "deployed_script"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std/" }
diff --git a/forc-plugins/forc-client/test/data/deployed_script/deployed_script-abi.json b/forc-plugins/forc-client/test/data/deployed_script/deployed_script-abi.json
new file mode 100644
index 00000000000..7689a658d2a
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_script/deployed_script-abi.json
@@ -0,0 +1,312 @@
+{
+  "programType": "script",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
+    {
+      "type": "((bool, u8, u16, u32, u64, u256, b256, str[4], (u8, bool), [u32; 3], struct StructWithGeneric<u8>, enum EnumWithGeneric<bool>), bool, u64, u8)",
+      "concreteTypeId": "25fbba860b8a1983ebcfa3f135136266a7edb7ca3a7e1f8ec988135c12a9f873",
+      "metadataTypeId": 2
+    },
+    {
+      "type": "(u8, bool)",
+      "concreteTypeId": "e0128f7be9902d1fe16326cafe703b52038064a7997b03ebfc1c9dd607e1536c",
+      "metadataTypeId": 1
+    },
+    {
+      "type": "[u32; 3]",
+      "concreteTypeId": "d9fac01ab38fe10950758ae9604da330d6406a71fda3ef1ea818121261132d56",
+      "metadataTypeId": 4
+    },
+    {
+      "type": "b256",
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+    },
+    {
+      "type": "bool",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    },
+    {
+      "type": "enum EnumWithGeneric<bool>",
+      "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
+      "metadataTypeId": 5,
+      "typeArguments": [
+        "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+      ]
+    },
+    {
+      "type": "str[4]",
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a"
+    },
+    {
+      "type": "struct StructWithGeneric<u8>",
+      "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
+      "metadataTypeId": 7,
+      "typeArguments": [
+        "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+      ]
+    },
+    {
+      "type": "u16",
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+    },
+    {
+      "type": "u256",
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+    },
+    {
+      "type": "u32",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+    },
+    {
+      "type": "u64",
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    },
+    {
+      "type": "u8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "metadataTypes": [
+    {
+      "type": "()",
+      "metadataTypeId": 0
+    },
+    {
+      "type": "(_, _)",
+      "metadataTypeId": 1,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        }
+      ]
+    },
+    {
+      "type": "(_, _, _, _)",
+      "metadataTypeId": 2,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": 3
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        }
+      ]
+    },
+    {
+      "type": "(_, _, _, _, _, _, _, _, _, _, _, _)",
+      "metadataTypeId": 3,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 1
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 4
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 7,
+          "typeArguments": [
+            {
+              "name": "",
+              "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+            }
+          ]
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 5,
+          "typeArguments": [
+            {
+              "name": "",
+              "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "type": "[_; 3]",
+      "metadataTypeId": 4,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+        }
+      ]
+    },
+    {
+      "type": "enum EnumWithGeneric",
+      "metadataTypeId": 5,
+      "components": [
+        {
+          "name": "VariantOne",
+          "typeId": 6
+        },
+        {
+          "name": "VariantTwo",
+          "typeId": 0
+        }
+      ],
+      "typeParameters": [
+        6
+      ]
+    },
+    {
+      "type": "generic D",
+      "metadataTypeId": 6
+    },
+    {
+      "type": "struct StructWithGeneric",
+      "metadataTypeId": 7,
+      "components": [
+        {
+          "name": "field_1",
+          "typeId": 6
+        },
+        {
+          "name": "field_2",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ],
+      "typeParameters": [
+        6
+      ]
+    }
+  ],
+  "functions": [
+    {
+      "inputs": [
+        {
+          "name": "a",
+          "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+        },
+        {
+          "name": "contract_addr",
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+        }
+      ],
+      "name": "main",
+      "output": "25fbba860b8a1983ebcfa3f135136266a7edb7ca3a7e1f8ec988135c12a9f873",
+      "attributes": null
+    }
+  ],
+  "loggedTypes": [
+    {
+      "logId": "14454674236531057292",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "messagesTypes": [],
+  "configurables": [
+    {
+      "name": "BOOL",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "offset": 8560
+    },
+    {
+      "name": "U8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "offset": 8672
+    },
+    {
+      "name": "U16",
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "offset": 8616
+    },
+    {
+      "name": "U32",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "offset": 8656
+    },
+    {
+      "name": "U64",
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "offset": 8664
+    },
+    {
+      "name": "U256",
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "offset": 8624
+    },
+    {
+      "name": "B256",
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "offset": 8528
+    },
+    {
+      "name": "STR_4",
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
+      "offset": 8600
+    },
+    {
+      "name": "TUPLE",
+      "concreteTypeId": "e0128f7be9902d1fe16326cafe703b52038064a7997b03ebfc1c9dd607e1536c",
+      "offset": 8608
+    },
+    {
+      "name": "ARRAY",
+      "concreteTypeId": "d9fac01ab38fe10950758ae9604da330d6406a71fda3ef1ea818121261132d56",
+      "offset": 8512
+    },
+    {
+      "name": "STRUCT",
+      "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
+      "offset": 8584
+    },
+    {
+      "name": "ENUM",
+      "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
+      "offset": 8568
+    }
+  ]
+}
\ No newline at end of file
diff --git a/forc-plugins/forc-client/test/data/deployed_script/deployed_script-loader-abi.json b/forc-plugins/forc-client/test/data/deployed_script/deployed_script-loader-abi.json
new file mode 100644
index 00000000000..81b65c43cd7
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_script/deployed_script-loader-abi.json
@@ -0,0 +1,312 @@
+{
+  "programType": "script",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
+    {
+      "type": "((bool, u8, u16, u32, u64, u256, b256, str[4], (u8, bool), [u32; 3], struct StructWithGeneric<u8>, enum EnumWithGeneric<bool>), bool, u64, u8)",
+      "concreteTypeId": "25fbba860b8a1983ebcfa3f135136266a7edb7ca3a7e1f8ec988135c12a9f873",
+      "metadataTypeId": 2
+    },
+    {
+      "type": "(u8, bool)",
+      "concreteTypeId": "e0128f7be9902d1fe16326cafe703b52038064a7997b03ebfc1c9dd607e1536c",
+      "metadataTypeId": 1
+    },
+    {
+      "type": "[u32; 3]",
+      "concreteTypeId": "d9fac01ab38fe10950758ae9604da330d6406a71fda3ef1ea818121261132d56",
+      "metadataTypeId": 4
+    },
+    {
+      "type": "b256",
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+    },
+    {
+      "type": "bool",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    },
+    {
+      "type": "enum EnumWithGeneric<bool>",
+      "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
+      "metadataTypeId": 5,
+      "typeArguments": [
+        "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+      ]
+    },
+    {
+      "type": "str[4]",
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a"
+    },
+    {
+      "type": "struct StructWithGeneric<u8>",
+      "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
+      "metadataTypeId": 7,
+      "typeArguments": [
+        "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+      ]
+    },
+    {
+      "type": "u16",
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+    },
+    {
+      "type": "u256",
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+    },
+    {
+      "type": "u32",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+    },
+    {
+      "type": "u64",
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    },
+    {
+      "type": "u8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "metadataTypes": [
+    {
+      "type": "()",
+      "metadataTypeId": 0
+    },
+    {
+      "type": "(_, _)",
+      "metadataTypeId": 1,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        }
+      ]
+    },
+    {
+      "type": "(_, _, _, _)",
+      "metadataTypeId": 2,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": 3
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        }
+      ]
+    },
+    {
+      "type": "(_, _, _, _, _, _, _, _, _, _, _, _)",
+      "metadataTypeId": 3,
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 1
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 4
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 7,
+          "typeArguments": [
+            {
+              "name": "",
+              "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+            }
+          ]
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 5,
+          "typeArguments": [
+            {
+              "name": "",
+              "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "type": "[_; 3]",
+      "metadataTypeId": 4,
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+        }
+      ]
+    },
+    {
+      "type": "enum EnumWithGeneric",
+      "metadataTypeId": 5,
+      "components": [
+        {
+          "name": "VariantOne",
+          "typeId": 6
+        },
+        {
+          "name": "VariantTwo",
+          "typeId": 0
+        }
+      ],
+      "typeParameters": [
+        6
+      ]
+    },
+    {
+      "type": "generic D",
+      "metadataTypeId": 6
+    },
+    {
+      "type": "struct StructWithGeneric",
+      "metadataTypeId": 7,
+      "components": [
+        {
+          "name": "field_1",
+          "typeId": 6
+        },
+        {
+          "name": "field_2",
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+        }
+      ],
+      "typeParameters": [
+        6
+      ]
+    }
+  ],
+  "functions": [
+    {
+      "inputs": [
+        {
+          "name": "a",
+          "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+        },
+        {
+          "name": "contract_addr",
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+        }
+      ],
+      "name": "main",
+      "output": "25fbba860b8a1983ebcfa3f135136266a7edb7ca3a7e1f8ec988135c12a9f873",
+      "attributes": null
+    }
+  ],
+  "loggedTypes": [
+    {
+      "logId": "14454674236531057292",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "messagesTypes": [],
+  "configurables": [
+    {
+      "name": "BOOL",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "offset": 136
+    },
+    {
+      "name": "U8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "offset": 248
+    },
+    {
+      "name": "U16",
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "offset": 192
+    },
+    {
+      "name": "U32",
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "offset": 232
+    },
+    {
+      "name": "U64",
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "offset": 240
+    },
+    {
+      "name": "U256",
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "offset": 200
+    },
+    {
+      "name": "B256",
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "offset": 104
+    },
+    {
+      "name": "STR_4",
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
+      "offset": 176
+    },
+    {
+      "name": "TUPLE",
+      "concreteTypeId": "e0128f7be9902d1fe16326cafe703b52038064a7997b03ebfc1c9dd607e1536c",
+      "offset": 184
+    },
+    {
+      "name": "ARRAY",
+      "concreteTypeId": "d9fac01ab38fe10950758ae9604da330d6406a71fda3ef1ea818121261132d56",
+      "offset": 88
+    },
+    {
+      "name": "STRUCT",
+      "concreteTypeId": "563310524b4f4447a10d0e50556310253dfb3b5eb4b29c3773222b737c8b7075",
+      "offset": 160
+    },
+    {
+      "name": "ENUM",
+      "concreteTypeId": "37cd1cba311039a851ac8bfa614cc41359b4ad95c8656fcef2e8f504fe7a1272",
+      "offset": 144
+    }
+  ]
+}
\ No newline at end of file
diff --git a/forc-plugins/forc-client/test/data/deployed_script/deployed_script.bin b/forc-plugins/forc-client/test/data/deployed_script/deployed_script.bin
new file mode 100644
index 00000000000..0daa7de8f3e
Binary files /dev/null and b/forc-plugins/forc-client/test/data/deployed_script/deployed_script.bin differ
diff --git a/forc-plugins/forc-client/test/data/deployed_script/src/main.sw b/forc-plugins/forc-client/test/data/deployed_script/src/main.sw
new file mode 100644
index 00000000000..c47105d4d74
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/deployed_script/src/main.sw
@@ -0,0 +1,72 @@
+script;
+
+use std::logging::log;
+
+#[allow(dead_code)]
+enum EnumWithGeneric<D> {
+    VariantOne: D,
+    VariantTwo: (),
+}
+
+struct StructWithGeneric<D> {
+    field_1: D,
+    field_2: u64,
+}
+
+abi MyContract {
+    fn test_function() -> bool;
+
+    #[storage(read)]
+    fn test_function_read() -> u8;
+
+    #[storage(read, write)]
+    fn test_function_write(value: u8) -> u8;
+}
+
+configurable {
+    BOOL: bool = true,
+    U8: u8 = 8,
+    U16: u16 = 16,
+    U32: u32 = 32,
+    U64: u64 = 63,
+    U256: u256 = 0x0000000000000000000000000000000000000000000000000000000000000008u256,
+    B256: b256 = 0x0101010101010101010101010101010101010101010101010101010101010101,
+    STR_4: str[4] = __to_str_array("fuel"),
+    TUPLE: (u8, bool) = (8, true),
+    ARRAY: [u32; 3] = [253, 254, 255],
+    STRUCT: StructWithGeneric<u8> = StructWithGeneric {
+        field_1: 8,
+        field_2: 16,
+    },
+    ENUM: EnumWithGeneric<bool> = EnumWithGeneric::VariantOne(true),
+}
+
+fn get_configurables() -> (bool, u8, u16, u32, u64, u256, b256, str[4], (u8, bool), [u32; 3], StructWithGeneric<u8>, EnumWithGeneric<bool>) {
+    (BOOL, U8, U16, U32, U64, U256, B256, STR_4, TUPLE, ARRAY, STRUCT, ENUM)
+}
+
+fn basic_function_with_input(a: u32) -> bool {
+    if a % 2 == 0 {
+        true
+    }else {
+        false
+    }
+}
+
+fn basic_function_without_input() -> u64 {
+    let a = 100;
+    let b = 25;
+    a*b
+}
+
+fn main(a: u32, contract_addr: b256) -> ((bool, u8, u16, u32, u64, u256, b256, str[4], (u8, bool), [u32; 3], StructWithGeneric<u8>, EnumWithGeneric<bool>), bool, u64, u8) {
+    log(U8);
+    let configs = get_configurables();
+    let with_in = basic_function_with_input(a);
+    let without_in = basic_function_without_input();
+
+    let contract_instance = abi(MyContract, contract_addr);
+    let from_contract = contract_instance.test_function_read();
+
+    return (configs, with_in, without_in, from_contract);
+}
diff --git a/forc-plugins/forc-client/test/data/standalone_contract/Forc.lock b/forc-plugins/forc-client/test/data/standalone_contract/Forc.lock
new file mode 100644
index 00000000000..7b517045569
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/standalone_contract/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-79BB3EA8498403DE"
+
+[[package]]
+name = "standalone_contract"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-79BB3EA8498403DE"
+dependencies = ["core"]
diff --git a/forc-plugins/forc-client/test/data/standalone_contract/Forc.toml b/forc-plugins/forc-client/test/data/standalone_contract/Forc.toml
index de97c7bf31f..2324ff98894 100644
--- a/forc-plugins/forc-client/test/data/standalone_contract/Forc.toml
+++ b/forc-plugins/forc-client/test/data/standalone_contract/Forc.toml
@@ -6,4 +6,4 @@ license = "Apache-2.0"
 name = "standalone_contract"
 
 [dependencies]
-std = { path = "../../../../../../../../sway-lib-std/" }
+std = { path = "../../../../../sway-lib-std/" }
diff --git a/forc-plugins/forc-client/test/data/standalone_contract/src/main.sw b/forc-plugins/forc-client/test/data/standalone_contract/src/main.sw
index 7d4a75493c6..49e0ac20ae2 100644
--- a/forc-plugins/forc-client/test/data/standalone_contract/src/main.sw
+++ b/forc-plugins/forc-client/test/data/standalone_contract/src/main.sw
@@ -1,11 +1,32 @@
 contract;
 
+storage {
+    value: u8 = 5,
+}
+
 abi MyContract {
     fn test_function() -> bool;
+
+    #[storage(read)]
+    fn test_function_read() -> u8;
+
+    #[storage(read, write)]
+    fn test_function_write(value: u8) -> u8;
 }
 
 impl MyContract for Contract {
     fn test_function() -> bool {
         true
     }
+
+    #[storage(read)]
+    fn test_function_read() -> u8 {
+        storage.value.read()
+    }
+
+    #[storage(read, write)]
+    fn test_function_write(value: u8) -> u8 {
+        storage.value.write(value);
+        storage.value.read()
+    }
 }
diff --git a/forc-plugins/forc-client/test/data/standalone_contract/standalone_contract-abi.json b/forc-plugins/forc-client/test/data/standalone_contract/standalone_contract-abi.json
new file mode 100644
index 00000000000..0dfb6f2fad7
--- /dev/null
+++ b/forc-plugins/forc-client/test/data/standalone_contract/standalone_contract-abi.json
@@ -0,0 +1,59 @@
+{
+  "programType": "contract",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
+    {
+      "type": "bool",
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    },
+    {
+      "type": "u8",
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+    }
+  ],
+  "metadataTypes": [],
+  "functions": [
+    {
+      "inputs": [],
+      "name": "test_function",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "attributes": null
+    },
+    {
+      "inputs": [],
+      "name": "test_function_read",
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read"
+          ]
+        }
+      ]
+    },
+    {
+      "inputs": [
+        {
+          "name": "value",
+          "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+        }
+      ],
+      "name": "test_function_write",
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "attributes": [
+        {
+          "name": "storage",
+          "arguments": [
+            "read",
+            "write"
+          ]
+        }
+      ]
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "configurables": []
+}
\ No newline at end of file
diff --git a/forc-plugins/forc-client/tests/deploy.rs b/forc-plugins/forc-client/tests/deploy.rs
new file mode 100644
index 00000000000..dae3c123f51
--- /dev/null
+++ b/forc-plugins/forc-client/tests/deploy.rs
@@ -0,0 +1,1313 @@
+use forc::cli::shared::Pkg;
+use forc_client::{
+    cmd,
+    op::{deploy, DeployedContract, DeployedExecutable, DeployedPackage},
+    util::{account::ForcClientAccount, tx::update_proxy_contract_target},
+    NodeTarget,
+};
+use forc_pkg::manifest::Proxy;
+use fuel_crypto::SecretKey;
+use fuel_tx::{ContractId, Salt};
+use fuels::{
+    macros::abigen,
+    types::{transaction::TxPolicies, AsciiString, Bits256, SizedAsciiString},
+};
+use fuels_accounts::{provider::Provider, wallet::WalletUnlocked, Account, ViewOnlyAccount};
+use portpicker::Port;
+use rand::thread_rng;
+use rexpect::spawn;
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    process::{Child, Command},
+    str::FromStr,
+};
+use tempfile::tempdir;
+use toml_edit::{value, DocumentMut, InlineTable, Item, Table, Value};
+
+fn get_workspace_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../")
+        .join("../")
+        .canonicalize()
+        .unwrap()
+}
+
+fn test_data_path() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("test")
+        .join("data")
+        .canonicalize()
+        .unwrap()
+}
+
+fn run_node() -> (Child, Port) {
+    let port = portpicker::pick_unused_port().expect("No ports free");
+
+    let child = Command::new("fuel-core")
+        .arg("run")
+        .arg("--debug")
+        .arg("--db-type")
+        .arg("in-memory")
+        .arg("--port")
+        .arg(port.to_string())
+        .spawn()
+        .expect("Failed to start fuel-core");
+    (child, port)
+}
+
+/// Copy a directory recursively from `source` to `dest`.
+fn copy_dir(source: &Path, dest: &Path) -> anyhow::Result<()> {
+    fs::create_dir_all(dest)?;
+    for e in fs::read_dir(source)? {
+        let entry = e?;
+        let file_type = entry.file_type()?;
+        if file_type.is_dir() {
+            copy_dir(&entry.path(), &dest.join(entry.file_name()))?;
+        } else {
+            fs::copy(entry.path(), dest.join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}
+
+/// Tries to get an `DeployedContract` out of the given `DeployedPackage`.
+/// Panics otherwise.
+fn expect_deployed_contract(deployed_package: DeployedPackage) -> DeployedContract {
+    if let DeployedPackage::Contract(contract) = deployed_package {
+        contract
+    } else {
+        println!("{deployed_package:?}");
+        panic!("expected deployed package to be a contract")
+    }
+}
+
+/// Tries to get a script (`DeployedExecutable`) out of given deployed package.
+/// Panics otherwise.
+fn expect_deployed_script(deployed_package: DeployedPackage) -> DeployedExecutable {
+    if let DeployedPackage::Script(script) = deployed_package {
+        script
+    } else {
+        panic!("expected deployed package to be a script")
+    }
+}
+
+/// Tries to get a predicate (`DeployedExecutable`) out of given deployed package.
+/// Panics otherwise.
+fn expect_deployed_predicate(deployed_package: DeployedPackage) -> DeployedExecutable {
+    if let DeployedPackage::Predicate(predicate) = deployed_package {
+        predicate
+    } else {
+        panic!("expected deployed package to be a predicate")
+    }
+}
+
+fn patch_manifest_file_with_path_std(manifest_dir: &Path) -> anyhow::Result<()> {
+    let toml_path = manifest_dir.join(sway_utils::constants::MANIFEST_FILE_NAME);
+    let toml_content = fs::read_to_string(&toml_path).unwrap();
+
+    let mut doc = toml_content.parse::<DocumentMut>().unwrap();
+    let new_std_path = get_workspace_root().join("sway-lib-std");
+
+    let mut std_dependency = InlineTable::new();
+    std_dependency.insert("path", Value::from(new_std_path.display().to_string()));
+    doc["dependencies"]["std"] = Item::Value(Value::InlineTable(std_dependency));
+
+    fs::write(&toml_path, doc.to_string()).unwrap();
+    Ok(())
+}
+
+fn patch_manifest_file_with_proxy_table(manifest_dir: &Path, proxy: Proxy) -> anyhow::Result<()> {
+    let toml_path = manifest_dir.join(sway_utils::constants::MANIFEST_FILE_NAME);
+    let toml_content = fs::read_to_string(&toml_path)?;
+    let mut doc = toml_content.parse::<DocumentMut>()?;
+
+    let proxy_table = doc.entry("proxy").or_insert(Item::Table(Table::new()));
+    let proxy_table = proxy_table.as_table_mut().unwrap();
+
+    proxy_table.insert("enabled", value(proxy.enabled));
+
+    if let Some(address) = proxy.address {
+        proxy_table.insert("address", value(address));
+    } else {
+        proxy_table.remove("address");
+    }
+
+    fs::write(&toml_path, doc.to_string())?;
+    Ok(())
+}
+
+fn update_main_sw(tmp_dir: &Path) -> anyhow::Result<()> {
+    let main_sw_path = tmp_dir.join("src").join("main.sw");
+    let content = fs::read_to_string(&main_sw_path)?;
+    let updated_content = content.replace("true", "false");
+    fs::write(main_sw_path, updated_content)?;
+    Ok(())
+}
+
+async fn assert_big_contract_calls(wallet: WalletUnlocked, contract_id: ContractId) {
+    abigen!(Contract(
+        name = "BigContract",
+        abi = "forc-plugins/forc-client/test/data/big_contract/big_contract-abi.json"
+    ));
+
+    let instance = BigContract::new(contract_id, wallet);
+
+    let result = instance.methods().large_blob().call().await.unwrap().value;
+    assert!(result);
+
+    let result = instance
+        .methods()
+        .enum_input_output(Location::Mars)
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, Location::Mars);
+
+    // Test enum with "tuple like struct" with simple value.
+    let result = instance
+        .methods()
+        .enum_input_output(Location::Earth(u64::MAX))
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, Location::Earth(u64::MAX));
+
+    // Test enum with "tuple like struct" with enum value.
+    let result = instance
+        .methods()
+        .enum_input_output(Location::SimpleJupiter(Color::Red))
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, Location::SimpleJupiter(Color::Red));
+
+    // Test enum with "tuple like struct" with enum value.
+    let result = instance
+        .methods()
+        .enum_input_output(Location::SimpleJupiter(Color::Blue(u64::MAX)))
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, Location::SimpleJupiter(Color::Blue(u64::MAX)));
+
+    // Test enum with "tuple like struct" with enum array value.
+    let result = instance
+        .methods()
+        .enum_input_output(Location::Jupiter([Color::Red, Color::Blue(u64::MAX)]))
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(
+        result,
+        Location::Jupiter([Color::Red, Color::Blue(u64::MAX)])
+    );
+
+    // Test enum with "tuple like struct" with struct array value.
+    let result = instance
+        .methods()
+        .enum_input_output(Location::SimplePluto(SimpleStruct {
+            a: true,
+            b: u64::MAX,
+        }))
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(
+        result,
+        Location::SimplePluto(SimpleStruct {
+            a: true,
+            b: u64::MAX,
+        })
+    );
+
+    let input = Person {
+        name: AsciiString::new("Alice".into()).unwrap(),
+        age: 42,
+        alive: true,
+        location: Location::Earth(1),
+        some_tuple: (false, 42),
+        some_array: [4, 2],
+        some_b_256: Bits256::zeroed(),
+    };
+    let result = instance
+        .methods()
+        .struct_input_output(input.clone())
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, input);
+
+    let _ = instance
+        .methods()
+        .push_storage_u16(42)
+        .call()
+        .await
+        .unwrap();
+    let result = instance
+        .methods()
+        .get_storage_u16(0)
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, 42);
+
+    let _ = instance
+        .methods()
+        .push_storage_simple(SimpleStruct {
+            a: true,
+            b: u64::MAX,
+        })
+        .call()
+        .await
+        .unwrap();
+    let result = instance
+        .methods()
+        .get_storage_simple(0)
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(
+        result,
+        SimpleStruct {
+            a: true,
+            b: u64::MAX,
+        }
+    );
+
+    let _ = instance
+        .methods()
+        .push_storage_location(Location::Mars)
+        .call()
+        .await
+        .unwrap();
+    let result = instance
+        .methods()
+        .get_storage_location(0)
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, Location::Mars);
+
+    let _ = instance
+        .methods()
+        .push_storage_location(Location::Earth(u64::MAX))
+        .call()
+        .await
+        .unwrap();
+    let result = instance
+        .methods()
+        .get_storage_location(1)
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(result, Location::Earth(u64::MAX));
+
+    let _ = instance
+        .methods()
+        .push_storage_location(Location::Jupiter([Color::Red, Color::Blue(u64::MAX)]))
+        .call()
+        .await
+        .unwrap();
+    let result = instance
+        .methods()
+        .get_storage_location(2)
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert_eq!(
+        result,
+        Location::Jupiter([Color::Red, Color::Blue(u64::MAX)])
+    );
+
+    let result = instance
+        .methods()
+        .assert_configurables()
+        .call()
+        .await
+        .unwrap()
+        .value;
+    assert!(result);
+}
+
+#[tokio::test]
+async fn test_simple_deploy() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let contract_ids = deploy(cmd).await.unwrap();
+    node.kill().unwrap();
+    let expected = vec![DeployedPackage::Contract(DeployedContract {
+        id: ContractId::from_str(
+            "e50f0b4b396504398c0aff45951b1e44e108399c856cb92257dfa58fe96d53eb",
+        )
+        .unwrap(),
+        proxy: None,
+        chunked: false,
+    })];
+
+    assert_eq!(contract_ids, expected)
+}
+
+#[tokio::test]
+async fn test_deploy_submit_only() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+
+    let target = NodeTarget {
+        node_url: Some(node_url),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        submit_only: true,
+        ..Default::default()
+    };
+    let contract_ids = deploy(cmd).await.unwrap();
+    node.kill().unwrap();
+    let expected = vec![DeployedPackage::Contract(DeployedContract {
+        id: ContractId::from_str(
+            "e50f0b4b396504398c0aff45951b1e44e108399c856cb92257dfa58fe96d53eb",
+        )
+        .unwrap(),
+        proxy: None,
+        chunked: false,
+    })];
+
+    assert_eq!(contract_ids, expected)
+}
+
+#[tokio::test]
+async fn test_deploy_fresh_proxy() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+    let proxy = Proxy {
+        enabled: true,
+        address: None,
+    };
+    patch_manifest_file_with_proxy_table(tmp_dir.path(), proxy).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let contract_ids = deploy(cmd).await.unwrap();
+    node.kill().unwrap();
+    let impl_contract = DeployedPackage::Contract(DeployedContract {
+        id: ContractId::from_str(
+            "e50f0b4b396504398c0aff45951b1e44e108399c856cb92257dfa58fe96d53eb",
+        )
+        .unwrap(),
+        proxy: Some(
+            ContractId::from_str(
+                "1c50e2d4d602fdd88b47fb7b84b7f87bbdefcf9b7e5985bb7ceeee9266a8e977",
+            )
+            .unwrap(),
+        ),
+        chunked: false,
+    });
+    let expected = vec![impl_contract];
+
+    assert_eq!(contract_ids, expected)
+}
+
+#[tokio::test]
+async fn test_proxy_contract_re_routes_call() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+    let proxy = Proxy {
+        enabled: true,
+        address: None,
+    };
+    patch_manifest_file_with_proxy_table(tmp_dir.path(), proxy).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_contract = expect_deployed_contract(deploy(cmd).await.unwrap().remove(0));
+    // At this point we deployed a contract with proxy.
+    let proxy_contract_id = deployed_contract.proxy.unwrap();
+    let impl_contract_id = deployed_contract.id;
+    // Make a contract call into proxy contract, and check if the initial
+    // contract returns a true.
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider));
+
+    abigen!(Contract(
+        name = "ImplementationContract",
+        abi = "forc-plugins/forc-client/test/data/standalone_contract/standalone_contract-abi.json"
+    ));
+
+    let impl_contract_a = ImplementationContract::new(proxy_contract_id, wallet_unlocked.clone());
+
+    // Test storage functions
+    let res = impl_contract_a
+        .methods()
+        .test_function_read()
+        .with_contract_ids(&[impl_contract_id.into()])
+        .call()
+        .await
+        .unwrap();
+    assert_eq!(res.value, 5);
+    let res = impl_contract_a
+        .methods()
+        .test_function_write(8)
+        .with_contract_ids(&[impl_contract_id.into()])
+        .call()
+        .await
+        .unwrap();
+    assert_eq!(res.value, 8);
+
+    let res = impl_contract_a
+        .methods()
+        .test_function()
+        .with_contract_ids(&[impl_contract_id.into()])
+        .call()
+        .await
+        .unwrap();
+    assert!(res.value);
+
+    update_main_sw(tmp_dir.path()).unwrap();
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_contract = expect_deployed_contract(deploy(cmd).await.unwrap().remove(0));
+    // proxy contract id should be the same.
+    let proxy_contract_after_update = deployed_contract.proxy.unwrap();
+    assert_eq!(proxy_contract_id, proxy_contract_after_update);
+    let impl_contract_id_after_update = deployed_contract.id;
+    assert!(impl_contract_id != impl_contract_id_after_update);
+    let impl_contract_a = ImplementationContract::new(proxy_contract_after_update, wallet_unlocked);
+
+    // Test storage functions
+    let res = impl_contract_a
+        .methods()
+        .test_function_read()
+        .with_contract_ids(&[impl_contract_id_after_update.into()])
+        .call()
+        .await
+        .unwrap();
+    // Storage should be preserved from the previous target contract.
+    assert_eq!(res.value, 8);
+    let res = impl_contract_a
+        .methods()
+        .test_function_write(9)
+        .with_contract_ids(&[impl_contract_id_after_update.into()])
+        .call()
+        .await
+        .unwrap();
+    assert_eq!(res.value, 9);
+
+    let res = impl_contract_a
+        .methods()
+        .test_function()
+        .with_contract_ids(&[impl_contract_id_after_update.into()])
+        .call()
+        .await
+        .unwrap();
+    assert!(!res.value);
+    node.kill().unwrap();
+}
+
+#[tokio::test]
+async fn test_non_owner_fails_to_set_target() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+    let proxy = Proxy {
+        enabled: true,
+        address: None,
+    };
+    patch_manifest_file_with_proxy_table(tmp_dir.path(), proxy).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let contract_id = expect_deployed_contract(deploy(cmd).await.unwrap().remove(0));
+    // Proxy contract's id.
+    let proxy_id = contract_id.proxy.unwrap();
+
+    // Create and fund an owner account and an attacker account.
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let attacker_secret_key = SecretKey::random(&mut thread_rng());
+    let attacker_wallet =
+        WalletUnlocked::new_from_private_key(attacker_secret_key, Some(provider.clone()));
+
+    let owner_secret_key =
+        SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let owner_wallet =
+        WalletUnlocked::new_from_private_key(owner_secret_key, Some(provider.clone()));
+    let base_asset_id = provider.base_asset_id();
+
+    // Fund attacker wallet so that it can try to make a set proxy target call.
+    owner_wallet
+        .transfer(
+            attacker_wallet.address(),
+            100000,
+            *base_asset_id,
+            TxPolicies::default(),
+        )
+        .await
+        .unwrap();
+
+    let dummy_contract_id_target = ContractId::default();
+    abigen!(Contract(name = "ProxyContract", abi = "{\"programType\":\"contract\",\"specVersion\":\"1\",\"encodingVersion\":\"1\",\"concreteTypes\":[{\"type\":\"()\",\"concreteTypeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"type\":\"enum standards::src5::AccessError\",\"concreteTypeId\":\"3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d\",\"metadataTypeId\":1},{\"type\":\"enum standards::src5::State\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"metadataTypeId\":2},{\"type\":\"enum std::option::Option<struct std::contract_id::ContractId>\",\"concreteTypeId\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"metadataTypeId\":4,\"typeArguments\":[\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\"]},{\"type\":\"enum sway_libs::ownership::errors::InitializationError\",\"concreteTypeId\":\"1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893\",\"metadataTypeId\":5},{\"type\":\"enum sway_libs::upgradability::errors::SetProxyOwnerError\",\"concreteTypeId\":\"3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74\",\"metadataTypeId\":6},{\"type\":\"str\",\"concreteTypeId\":\"8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a\"},{\"type\":\"struct std::contract_id::ContractId\",\"concreteTypeId\":\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\",\"metadataTypeId\":9},{\"type\":\"struct sway_libs::upgradability::events::ProxyOwnerSet\",\"concreteTypeId\":\"96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247\",\"metadataTypeId\":10},{\"type\":\"struct sway_libs::upgradability::events::ProxyTargetSet\",\"concreteTypeId\":\"1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8\",\"metadataTypeId\":11}],\"metadataTypes\":[{\"type\":\"b256\",\"metadataTypeId\":0},{\"type\":\"enum standards::src5::AccessError\",\"metadataTypeId\":1,\"components\":[{\"name\":\"NotOwner\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum standards::src5::State\",\"metadataTypeId\":2,\"components\":[{\"name\":\"Uninitialized\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"name\":\"Initialized\",\"typeId\":3},{\"name\":\"Revoked\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum std::identity::Identity\",\"metadataTypeId\":3,\"components\":[{\"name\":\"Address\",\"typeId\":8},{\"name\":\"ContractId\",\"typeId\":9}]},{\"type\":\"enum std::option::Option\",\"metadataTypeId\":4,\"components\":[{\"name\":\"None\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"},{\"name\":\"Some\",\"typeId\":7}],\"typeParameters\":[7]},{\"type\":\"enum sway_libs::ownership::errors::InitializationError\",\"metadataTypeId\":5,\"components\":[{\"name\":\"CannotReinitialized\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"enum sway_libs::upgradability::errors::SetProxyOwnerError\",\"metadataTypeId\":6,\"components\":[{\"name\":\"CannotUninitialize\",\"typeId\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\"}]},{\"type\":\"generic T\",\"metadataTypeId\":7},{\"type\":\"struct std::address::Address\",\"metadataTypeId\":8,\"components\":[{\"name\":\"bits\",\"typeId\":0}]},{\"type\":\"struct std::contract_id::ContractId\",\"metadataTypeId\":9,\"components\":[{\"name\":\"bits\",\"typeId\":0}]},{\"type\":\"struct sway_libs::upgradability::events::ProxyOwnerSet\",\"metadataTypeId\":10,\"components\":[{\"name\":\"new_proxy_owner\",\"typeId\":2}]},{\"type\":\"struct sway_libs::upgradability::events::ProxyTargetSet\",\"metadataTypeId\":11,\"components\":[{\"name\":\"new_target\",\"typeId\":9}]}],\"functions\":[{\"inputs\":[],\"name\":\"proxy_target\",\"output\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Returns the target contract of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Returns\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * [Option<ContractId>] - The new proxy contract to which all fallback calls will be passed or `None`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\"]}]},{\"inputs\":[{\"name\":\"new_target\",\"concreteTypeId\":\"29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54\"}],\"name\":\"set_proxy_target\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Change the target contract of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can only be called by the `proxy_owner`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Arguments\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * `new_target`: [ContractId] - The new proxy contract to which all fallback calls will be passed.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When not called by `proxy_owner`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Write: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\",\"write\"]}]},{\"inputs\":[],\"name\":\"proxy_owner\",\"output\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Returns the owner of the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Returns\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * [State] - Represents the state of ownership for this contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"read\"]}]},{\"inputs\":[],\"name\":\"initialize_proxy\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Initializes the proxy contract.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method sets the storage values using the values of the configurable constants `INITIAL_TARGET` and `INITIAL_OWNER`.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This then allows methods that write to storage to be called.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can only be called once.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When `storage::SRC14.proxy_owner` is not [State::Uninitialized].\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Writes: `2`\"]},{\"name\":\"storage\",\"arguments\":[\"write\"]}]},{\"inputs\":[{\"name\":\"new_proxy_owner\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\"}],\"name\":\"set_proxy_owner\",\"output\":\"2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d\",\"attributes\":[{\"name\":\"doc-comment\",\"arguments\":[\" Changes proxy ownership to the passed State.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Additional Information\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" This method can be used to transfer ownership between Identities or to revoke ownership.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Arguments\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * `new_proxy_owner`: [State] - The new state of the proxy ownership.\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Reverts\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When the sender is not the current proxy owner.\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * When the new state of the proxy ownership is [State::Uninitialized].\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" # Number of Storage Accesses\"]},{\"name\":\"doc-comment\",\"arguments\":[\"\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Reads: `1`\"]},{\"name\":\"doc-comment\",\"arguments\":[\" * Writes: `1`\"]},{\"name\":\"storage\",\"arguments\":[\"write\"]}]}],\"loggedTypes\":[{\"logId\":\"4571204900286667806\",\"concreteTypeId\":\"3f702ea3351c9c1ece2b84048006c8034a24cbc2bad2e740d0412b4172951d3d\"},{\"logId\":\"2151606668983994881\",\"concreteTypeId\":\"1ddc0adda1270a016c08ffd614f29f599b4725407c8954c8b960bdf651a9a6c8\"},{\"logId\":\"2161305517876418151\",\"concreteTypeId\":\"1dfe7feadc1d9667a4351761230f948744068a090fe91b1bc6763a90ed5d3893\"},{\"logId\":\"4354576968059844266\",\"concreteTypeId\":\"3c6e90ae504df6aad8b34a93ba77dc62623e00b777eecacfa034a8ac6e890c74\"},{\"logId\":\"10870989709723147660\",\"concreteTypeId\":\"96dd838b44f99d8ccae2a7948137ab6256c48ca4abc6168abc880de07fba7247\"},{\"logId\":\"10098701174489624218\",\"concreteTypeId\":\"8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a\"}],\"messagesTypes\":[],\"configurables\":[{\"name\":\"INITIAL_TARGET\",\"concreteTypeId\":\"0d79387ad3bacdc3b7aad9da3a96f4ce60d9a1b6002df254069ad95a3931d5c8\",\"offset\":13368},{\"name\":\"INITIAL_OWNER\",\"concreteTypeId\":\"192bc7098e2fe60635a9918afb563e4e5419d386da2bdbf0d716b4bc8549802c\",\"offset\":13320}]}",));
+
+    let wallet = WalletUnlocked::new_from_private_key(attacker_secret_key, Some(provider.clone()));
+    let attacker_account = ForcClientAccount::Wallet(wallet);
+    // Try to change target of the proxy with a random wallet which is not the owner of the proxy.
+    let res = update_proxy_contract_target(&attacker_account, proxy_id, dummy_contract_id_target)
+        .await
+        .err()
+        .unwrap();
+
+    node.kill().unwrap();
+    assert!(res
+        .to_string()
+        .starts_with("transaction reverted: NotOwner"));
+}
+
+// TODO: https://github.com/FuelLabs/sway/issues/6283
+// Add interactive tests for the happy path cases. This requires starting the node with funded accounts and setting up
+// the wallet with the correct password. The tests should be run in a separate test suite that is not run by default.
+// It would also require overriding `default_wallet_path` function for tests, so as not to interfere with the user's wallet.
+
+#[test]
+fn test_deploy_interactive_wrong_password() -> Result<(), rexpect::error::Error> {
+    let (mut node, port) = run_node();
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+
+    // Spawn the forc-deploy binary using cargo run
+    let project_dir = test_data_path().join("standalone_contract");
+    let mut process = spawn(
+        &format!(
+            "cargo run --bin forc-deploy -- --node-url {node_url} -p {}",
+            project_dir.display()
+        ),
+        Some(300000),
+    )?;
+
+    // Confirmation prompts
+    process
+        .exp_string("\u{1b}[1;32mConfirming\u{1b}[0m transactions [deploy standalone_contract]")?;
+    process.exp_string(&format!("Network: {node_url}"))?;
+    process.exp_string("Wallet: ")?;
+    process.exp_string("Wallet password")?;
+    process.send_line("mock_password")?;
+
+    process.process.exit()?;
+    node.kill().unwrap();
+    Ok(())
+}
+
+#[tokio::test]
+async fn chunked_deploy() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("big_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_contract = expect_deployed_contract(deploy(cmd).await.unwrap().remove(0));
+    node.kill().unwrap();
+
+    assert!(deployed_contract.chunked);
+}
+
+#[tokio::test]
+async fn chunked_deploy_re_routes_calls() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("big_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_contract = expect_deployed_contract(deploy(cmd).await.unwrap().remove(0));
+
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider));
+
+    assert_big_contract_calls(wallet_unlocked, deployed_contract.id).await;
+
+    node.kill().unwrap();
+}
+
+#[tokio::test]
+async fn chunked_deploy_with_proxy_re_routes_call() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("big_contract");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+    let proxy = Proxy {
+        enabled: true,
+        address: None,
+    };
+    patch_manifest_file_with_proxy_table(tmp_dir.path(), proxy).unwrap();
+
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_contract = expect_deployed_contract(deploy(cmd).await.unwrap().remove(0));
+
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider));
+
+    assert_big_contract_calls(wallet_unlocked, deployed_contract.id).await;
+
+    node.kill().unwrap();
+}
+
+#[tokio::test]
+async fn can_deploy_script() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("deployed_script");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+
+    expect_deployed_script(deploy(cmd).await.unwrap().remove(0));
+    node.kill().unwrap();
+}
+
+#[tokio::test]
+async fn deploy_script_calls() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("deployed_script");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+
+    expect_deployed_script(deploy(cmd).await.unwrap().remove(0));
+
+    // Deploy the contract the script is going to be calling.
+    let contract_tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, contract_tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(contract_tmp_dir.path()).unwrap();
+
+    let pkg = Pkg {
+        path: Some(contract_tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_packages = deploy(cmd).await.unwrap().remove(0);
+    let contract = expect_deployed_contract(deployed_packages);
+    let contract_id = contract.id;
+
+    abigen!(Script(
+        name = "MyScript",
+        abi = "forc-plugins/forc-client/test/data/deployed_script/deployed_script-abi.json"
+    ));
+
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider));
+
+    let loader_path = tmp_dir.path().join("out/deployed_script-loader.bin");
+    let instance = MyScript::new(wallet_unlocked, &loader_path.display().to_string());
+
+    let contract_id_bits256 = Bits256(contract.id.into());
+    let call_handler = instance
+        .main(10, contract_id_bits256)
+        .with_contract_ids(&[contract_id.into()])
+        .call()
+        .await
+        .unwrap();
+    let (configs, with_input, without_input, from_contract) = call_handler.value;
+    let receipts = call_handler.receipts;
+
+    assert!(configs.0); // bool
+    assert_eq!(configs.1, 8); // u8
+    assert_eq!(configs.2, 16); // u16
+    assert_eq!(configs.3, 32); // u32
+    assert_eq!(configs.4, 63); // u64
+    assert_eq!(configs.5, 8.into()); // u256
+    assert_eq!(
+        configs.6,
+        Bits256::from_hex_str("0x0101010101010101010101010101010101010101010101010101010101010101")
+            .unwrap()
+    ); // b256
+    assert_eq!(
+        configs.7,
+        SizedAsciiString::new("fuel".to_string()).unwrap()
+    ); // str[4]
+    assert_eq!(configs.8, (8, true)); // tuple
+    assert_eq!(configs.9, [253, 254, 255]); // array
+
+    let expected_struct = StructWithGeneric {
+        field_1: 8,
+        field_2: 16,
+    };
+    assert_eq!(configs.10, expected_struct); // struct
+
+    let expected_enum = EnumWithGeneric::VariantOne(true);
+    assert_eq!(configs.11, expected_enum); // enum
+
+    assert!(with_input); // 10 % 2 == 0
+    assert_eq!(without_input, 2500); // 25 * 100 = 2500
+
+    assert_eq!(from_contract, 5);
+
+    receipts.iter().find(|receipt| {
+        if let fuel_tx::Receipt::LogData { data, .. } = receipt {
+            *data == Some(vec![0x08])
+        } else {
+            false
+        }
+    });
+
+    node.kill().unwrap();
+}
+
+#[tokio::test]
+async fn can_deploy_predicates() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("deployed_predicate");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+
+    expect_deployed_predicate(deploy(cmd).await.unwrap().remove(0));
+    node.kill().unwrap();
+}
+
+#[tokio::test]
+async fn deployed_predicate_call() {
+    let (mut node, port) = run_node();
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("deployed_predicate");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    expect_deployed_predicate(deploy(cmd).await.unwrap().remove(0));
+
+    abigen!(Predicate(
+        name = "MyPredicate",
+        abi = "forc-plugins/forc-client/test/data/deployed_predicate/deployed_predicate-abi.json"
+    ));
+
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let base_asset_id = *provider.base_asset_id();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider.clone()));
+    let loader_path = tmp_dir.path().join("out/deployed_predicate-loader.bin");
+    let strct = StructWithGeneric {
+        field_1: 8,
+        field_2: 16,
+    };
+    let enm = EnumWithGeneric::VariantOne(true);
+    let encoded_data = MyPredicateEncoder::default()
+        .encode_data(true, 8, strct, enm)
+        .unwrap();
+    let predicate: fuels::prelude::Predicate =
+        fuels::prelude::Predicate::load_from(&loader_path.display().to_string())
+            .unwrap()
+            .with_data(encoded_data)
+            .with_provider(provider);
+
+    // lock some amount under the predicate
+    wallet_unlocked
+        .transfer(
+            predicate.address(),
+            500,
+            base_asset_id,
+            TxPolicies::default(),
+        )
+        .await
+        .unwrap();
+
+    // Check predicate balance.
+    let balance = predicate.get_asset_balance(&base_asset_id).await.unwrap();
+    assert_eq!(balance, 500);
+
+    // Try to spend it
+    let amount_to_unlock = 300;
+    predicate
+        .transfer(
+            wallet_unlocked.address(),
+            amount_to_unlock,
+            base_asset_id,
+            TxPolicies::default(),
+        )
+        .await
+        .unwrap();
+
+    // Check predicate balance again.
+    let balance = predicate.get_asset_balance(&base_asset_id).await.unwrap();
+    assert_eq!(balance, 200);
+
+    node.kill().unwrap();
+}
+
+/// Generates a script instance using SDK, and returns the result as a string.
+async fn call_with_sdk_generated_overrides(node_url: &str, contract_id: ContractId) -> String {
+    let project_dir = test_data_path().join("deployed_script");
+    abigen!(Script(
+        name = "MyScript",
+        abi = "forc-plugins/forc-client/test/data/deployed_script/deployed_script-abi.json"
+    ));
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider.clone()));
+    let bin_dir = project_dir.join("deployed_script.bin");
+    let script_instance = MyScript::new(wallet_unlocked, bin_dir.display().to_string().as_str());
+
+    let strc = StructWithGeneric {
+        field_1: 1u8,
+        field_2: 2,
+    };
+    let encoded = MyScriptConfigurables::default()
+        .with_BOOL(false)
+        .unwrap()
+        .with_U8(1)
+        .unwrap()
+        .with_U16(2)
+        .unwrap()
+        .with_U32(3)
+        .unwrap()
+        .with_U64(4)
+        .unwrap()
+        .with_U256(5.into())
+        .unwrap()
+        .with_B256(Bits256::zeroed())
+        .unwrap()
+        .with_ARRAY([1, 2, 3])
+        .unwrap()
+        .with_STRUCT(strc)
+        .unwrap()
+        .with_ENUM(EnumWithGeneric::VariantTwo)
+        .unwrap();
+
+    let mut script_instance_with_configs = script_instance.with_configurables(encoded);
+
+    let loader_from_sdk = script_instance_with_configs
+        .convert_into_loader()
+        .await
+        .unwrap();
+
+    let contract_ids_bits256 = Bits256(contract_id.into());
+    format!(
+        "{:?}",
+        loader_from_sdk
+            .main(10, contract_ids_bits256)
+            .with_contract_ids(&[contract_id.into()])
+            .call()
+            .await
+            .unwrap()
+            .value
+    )
+}
+
+/// Generates a script instance using the shifted abi, and returns the result as a string.
+async fn call_with_forc_generated_overrides(node_url: &str, contract_id: ContractId) -> String {
+    let provider = Provider::connect(&node_url).await.unwrap();
+    let secret_key = SecretKey::from_str(forc_client::constants::DEFAULT_PRIVATE_KEY).unwrap();
+    let wallet_unlocked = WalletUnlocked::new_from_private_key(secret_key, Some(provider.clone()));
+    let tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("deployed_script");
+    copy_dir(&project_dir, tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(tmp_dir.path()).unwrap();
+
+    let target = NodeTarget {
+        node_url: Some(node_url.to_string()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let pkg = Pkg {
+        path: Some(tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+
+    expect_deployed_script(deploy(cmd).await.unwrap().remove(0));
+
+    // Since `abigen!` macro does not allow for dynamic paths, we need to
+    // pre-generate the loader bin and abi and read them from project dir. Here
+    // we are ensuring forc-deploy indeed generated the files we are basing our
+    // tests below.
+    let generated_loader_abi_path = tmp_dir.path().join("out/deployed_script-loader-abi.json");
+    let generated_loader_abi = fs::read_to_string(generated_loader_abi_path).unwrap();
+
+    // this path is basically, `forc-plugins/forc-client/test/data/deployed_script/deployed_script-loader-abi.json`.
+    let used_loader_abi_path = project_dir.join("deployed_script-loader-abi.json");
+    let used_loader_abi = fs::read_to_string(used_loader_abi_path).unwrap();
+
+    assert_eq!(generated_loader_abi, used_loader_abi);
+
+    let generated_loader_bin = tmp_dir.path().join("out/deployed_script-loader.bin");
+    abigen!(Script(
+        name = "MyScript",
+        abi = "forc-plugins/forc-client/test/data/deployed_script/deployed_script-loader-abi.json"
+    ));
+    let forc_generated_script_instance = MyScript::new(
+        wallet_unlocked,
+        generated_loader_bin.display().to_string().as_str(),
+    );
+    let strc = StructWithGeneric {
+        field_1: 1u8,
+        field_2: 2,
+    };
+    let encoded = MyScriptConfigurables::default()
+        .with_BOOL(false)
+        .unwrap()
+        .with_U8(1)
+        .unwrap()
+        .with_U16(2)
+        .unwrap()
+        .with_U32(3)
+        .unwrap()
+        .with_U64(4)
+        .unwrap()
+        .with_U256(5.into())
+        .unwrap()
+        .with_B256(Bits256::zeroed())
+        .unwrap()
+        .with_ARRAY([1, 2, 3])
+        .unwrap()
+        .with_STRUCT(strc)
+        .unwrap()
+        .with_ENUM(EnumWithGeneric::VariantTwo)
+        .unwrap();
+
+    let forc_generated_script_with_configs =
+        forc_generated_script_instance.with_configurables(encoded);
+    let contract_ids_bits256 = Bits256(contract_id.into());
+    format!(
+        "{:?}",
+        forc_generated_script_with_configs
+            .main(10, contract_ids_bits256)
+            .with_contract_ids(&[contract_id.into()])
+            .call()
+            .await
+            .unwrap()
+            .value
+    )
+}
+
+#[tokio::test]
+async fn offset_shifted_abi_works() {
+    // To test if offset shifted abi works or not, we generate a loader
+    // contract using sdk and give a configurable override, and call the
+    // main function.
+
+    // We also create the shited abi using forc-deploy and create a script
+    // instance using this new shifted abi, and generate a normal script out of
+    // the loader binary generated again by forc-deploy.
+
+    // We then override the configurables with the same values as sdk flow on
+    // this script, generated with loader abi and bin coming from forc-deploy.
+
+    // If returned value is equal, than the configurables work correctly.
+    let (mut node, port) = run_node();
+    // Deploy the contract the script is going to be calling.
+    let contract_tmp_dir = tempdir().unwrap();
+    let project_dir = test_data_path().join("standalone_contract");
+    copy_dir(&project_dir, contract_tmp_dir.path()).unwrap();
+    patch_manifest_file_with_path_std(contract_tmp_dir.path()).unwrap();
+
+    let pkg = Pkg {
+        path: Some(contract_tmp_dir.path().display().to_string()),
+        ..Default::default()
+    };
+
+    let node_url = format!("http://127.0.0.1:{}/v1/graphql", port);
+    let target = NodeTarget {
+        node_url: Some(node_url.clone()),
+        target: None,
+        testnet: false,
+        mainnet: false,
+    };
+    let cmd = cmd::Deploy {
+        pkg,
+        salt: Some(vec![format!("{}", Salt::default())]),
+        node: target,
+        default_signer: true,
+        ..Default::default()
+    };
+    let deployed_packages = deploy(cmd).await.unwrap().remove(0);
+    let contract = expect_deployed_contract(deployed_packages);
+    let contract_id = contract.id;
+    // Generating the sdk loader bytecode with configurables.
+    let loader_with_configs_from_sdk =
+        call_with_sdk_generated_overrides(&node_url, contract_id).await;
+
+    // Genearating the forc-deploy loader bytecode and loader abi.
+    let loader_with_configs_from_forc =
+        call_with_forc_generated_overrides(&node_url, contract_id).await;
+    pretty_assertions::assert_eq!(loader_with_configs_from_forc, loader_with_configs_from_sdk);
+
+    node.kill().unwrap()
+}
diff --git a/forc-plugins/forc-crypto/Cargo.toml b/forc-plugins/forc-crypto/Cargo.toml
index ca598c5d7e2..bea4711b7d5 100644
--- a/forc-plugins/forc-crypto/Cargo.toml
+++ b/forc-plugins/forc-crypto/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-crypto"
-version = "0.60.0"
+version.workspace = true
 description = "A `forc` plugin for handling various cryptographic operations and conversions."
 authors.workspace = true
 edition.workspace = true
@@ -9,23 +9,34 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1.0.75"
-async-trait = "0.1.58"
-atty = "0.2.14"
-clap = { version = "4.5.4", features = ["derive", "env"] }
-forc-tracing = { version = "0.60.0", path = "../../forc-tracing" }
-forc-util = { version = "0.60.0", path = "../../forc-util" }
-fuel-core-types = { workspace = true }
+anyhow.workspace = true
+async-trait.workspace = true
+atty.workspace = true
+clap = { workspace = true, features = ["derive", "env"] }
+forc-tracing.workspace = true
+forc-util.workspace = true
+fuel-core-types.workspace = true
 fuel-crypto = { workspace = true, features = ["random"] }
-fuels-core = { workspace = true }
-futures = "0.3"
-hex = "0.4.3"
-libp2p-identity = { version = "0.2.4", features = ["secp256k1", "peerid"] }
-rand = "0.8"
-serde = "1.0"
-serde_json = "1"
-serde_yaml = "0.9.27"
-sha3 = "0.10.8"
-termion = "2.0.1"
-tokio = { version = "1.8", features = ["macros", "rt-multi-thread", "process"] }
-tracing = "0.1"
+fuels-accounts.workspace = true
+fuels-core.workspace = true
+futures.workspace = true
+hex.workspace = true
+libp2p-identity = { workspace = true, features = ["peerid", "secp256k1"] }
+rand.workspace = true
+rayon.workspace = true
+regex.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_yaml.workspace = true
+sha3.workspace = true
+termion.workspace = true
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "process"] }
+tracing.workspace = true
+
+[dev-dependencies]
+criterion = "0.5"
+tempfile.workspace = true
+
+[[bench]]
+name = "bench_main"
+harness = false
diff --git a/forc-plugins/forc-crypto/benches/bench_main.rs b/forc-plugins/forc-crypto/benches/bench_main.rs
new file mode 100644
index 00000000000..675923911cb
--- /dev/null
+++ b/forc-plugins/forc-crypto/benches/bench_main.rs
@@ -0,0 +1,73 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use forc_crypto::keys::vanity::{find_vanity_address_with_timeout, HexMatcher, RegexMatcher};
+use rayon::iter::Either;
+
+fn benchmark_vanity_address(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Vanity Address Generation");
+
+    // Benchmark HexMatcher with prefix
+    group.bench_function("HexMatcher (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("a", "").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark HexMatcher with suffix
+    group.bench_function("HexMatcher (ends with 'f')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("", "f").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark HexMatcher with both prefix and suffix
+    group.bench_function("HexMatcher (starts with 'a' ends with 'f')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("a", "f").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark RegexMatcher with simple pattern
+    group.bench_function("RegexMatcher (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Left(RegexMatcher::new("^a.*").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark RegexMatcher with complex pattern
+    group.bench_function("RegexMatcher (contains two consecutive digits)", |b| {
+        b.iter(|| {
+            let matcher = Either::Left(RegexMatcher::new(r"[0-9]{2}").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark with mnemonic generation
+    group.bench_function("HexMatcher with Mnemonic (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("a", "").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), true, None)
+        })
+    });
+
+    group.bench_function("RegexMatcher with Mnemonic (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Left(RegexMatcher::new("^a.*").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), true, None)
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .sample_size(10) // Reduced sample size due to potentially long-running benchmarks
+        .measurement_time(std::time::Duration::from_secs(20));
+    targets = benchmark_vanity_address
+}
+criterion_main!(benches);
diff --git a/forc-plugins/forc-crypto/src/args.rs b/forc-plugins/forc-crypto/src/args.rs
index 8e4bcee25fd..4201894632c 100644
--- a/forc-plugins/forc-crypto/src/args.rs
+++ b/forc-plugins/forc-crypto/src/args.rs
@@ -24,17 +24,17 @@ forc_util::cli_examples! {
 pub struct HashArgs {
     /// This argument is optional, it can be either:
     ///
-    ///     1. A path to a file. If that is the case, the content of the file is
-    ///        loaded.
+    /// 1. A path to a file. If that is the case, the content of the file is
+    ///    loaded
     ///
-    ///     2. A binary string encoded as a hex string. If that is the case, the
-    ///        hex is decoded and passed as a Vec<u8>
+    /// 2. A binary string encoded as a hex string. If that is the case, the
+    ///    hex is decoded and passed as a Vec<u8>
     ///
-    ///     3. A string. This is the last option, if the string is "-", `stdin`
-    ///        is read instead. Otherwise the raw string is converted to a Vec<u8>
-    ///        and passed
+    /// 3. A string. This is the last option, if the string is "-", "stdin"
+    ///    is read instead. Otherwise the raw string is converted to a Vec<u8>
+    ///    and passed
     ///
-    ///     4. If it nos not provided, `stdin` is read
+    /// 4. If it is not provided, "stdin" is read
     content_or_filepath: Option<String>,
 }
 
diff --git a/forc-plugins/forc-crypto/src/keys/mod.rs b/forc-plugins/forc-crypto/src/keys/mod.rs
index 9741e32623c..8935b5f366e 100644
--- a/forc-plugins/forc-crypto/src/keys/mod.rs
+++ b/forc-plugins/forc-crypto/src/keys/mod.rs
@@ -3,6 +3,7 @@ use clap::ValueEnum;
 pub mod get_public_key;
 pub mod new_key;
 pub mod parse_secret;
+pub mod vanity;
 
 #[derive(Clone, Debug, Default, ValueEnum)]
 pub enum KeyType {
diff --git a/forc-plugins/forc-crypto/src/keys/vanity.rs b/forc-plugins/forc-crypto/src/keys/vanity.rs
new file mode 100644
index 00000000000..640165dc818
--- /dev/null
+++ b/forc-plugins/forc-crypto/src/keys/vanity.rs
@@ -0,0 +1,457 @@
+use fuel_crypto::{fuel_types::Address, PublicKey, SecretKey};
+use fuels_accounts::wallet::{generate_mnemonic_phrase, DEFAULT_DERIVATION_PATH_PREFIX};
+use fuels_core::types::{
+    bech32::{Bech32Address, FUEL_BECH32_HRP},
+    checksum_address::checksum_encode,
+};
+use rayon::iter::{self, Either, ParallelIterator};
+use regex::Regex;
+use serde_json::json;
+use std::{
+    path::PathBuf,
+    time::{Duration, Instant},
+};
+use tokio::runtime::Runtime;
+
+forc_util::cli_examples! {
+    crate::Command {
+        [ Generate a checksummed vanity address with a given prefix => "forc crypto vanity --starts-with \"aaa\"" ]
+        [ Generate a checksummed vanity address with a given suffix => "forc crypto vanity --ends-with \"aaa\"" ]
+        [ Generate a checksummed vanity address with a given prefix and suffix => "forc crypto vanity --starts-with \"00\" --ends-with \"ff\"" ]
+        [ Generate a checksummed vanity address with a given regex pattern => "forc crypto vanity --regex \"^00.*ff$\"" ]
+    }
+}
+
+fn validate_hex_string(s: &str) -> Result<String, String> {
+    if !s.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Err("Pattern must contain only hex characters (0-9, a-f)".to_string());
+    }
+    Ok(s.to_string())
+}
+
+fn validate_regex_pattern(s: &str) -> Result<String, String> {
+    if s.len() > 128 {
+        return Err("Regex pattern too long: max 128 characters".to_string());
+    }
+
+    if let Err(e) = Regex::new(&format!("(?i){}", s)) {
+        return Err(format!("Invalid regex pattern: {}", e));
+    }
+
+    Ok(s.to_string())
+}
+
+#[derive(Debug, clap::Parser)]
+#[clap(
+    version,
+    about = "Generate a vanity address",
+    after_help = "Generate vanity addresses for the Fuel blockchain"
+)]
+pub struct Arg {
+    /// Desired hex string prefix for the address
+    #[arg(
+        long,
+        value_name = "HEX_STRING",
+        required_unless_present = "ends_with",
+        required_unless_present = "regex",
+        conflicts_with = "regex",
+        value_parser = validate_hex_string,
+    )]
+    pub starts_with: Option<String>,
+
+    /// Desired hex string suffix for the address
+    #[arg(long, value_name = "HEX_STRING", conflicts_with = "regex", value_parser = validate_hex_string)]
+    pub ends_with: Option<String>,
+
+    /// Desired regex pattern to match the entire address (case-insensitive)
+    #[arg(long, value_name = "PATTERN", conflicts_with = "starts_with", value_parser = validate_regex_pattern)]
+    pub regex: Option<String>,
+
+    /// Timeout in seconds for address generation
+    #[arg(long, value_name = "SECONDS")]
+    pub timeout: Option<u64>,
+
+    /// Return mnemonic with address (default false)
+    #[arg(long)]
+    pub mnemonic: bool,
+
+    /// Path to save the generated vanity address to.
+    #[arg(long, value_hint = clap::ValueHint::FilePath, value_name = "PATH")]
+    pub save_path: Option<PathBuf>,
+}
+
+impl Arg {
+    pub fn validate(&self) -> anyhow::Result<()> {
+        let total_length = self.starts_with.as_ref().map_or(0, |s| s.len())
+            + self.ends_with.as_ref().map_or(0, |s| s.len());
+        if total_length > 64 {
+            return Err(anyhow::anyhow!(
+                "Combined pattern length exceeds 64 characters"
+            ));
+        }
+        Ok(())
+    }
+}
+
+pub fn handler(args: Arg) -> anyhow::Result<serde_json::Value> {
+    args.validate()?;
+
+    let Arg {
+        starts_with,
+        ends_with,
+        regex,
+        mnemonic,
+        timeout,
+        save_path,
+    } = args;
+
+    let matcher = if let Some(pattern) = regex {
+        Either::Left(RegexMatcher::new(&pattern)?)
+    } else {
+        let starts_with = starts_with.as_deref().unwrap_or("");
+        let ends_with = ends_with.as_deref().unwrap_or("");
+        Either::Right(HexMatcher::new(starts_with, ends_with)?)
+    };
+
+    println!("Starting to generate vanity address...");
+    let start_time = Instant::now();
+
+    let result = find_vanity_address_with_timeout(matcher, mnemonic, timeout)?;
+    let (address, secret_key, mnemonic) = result;
+
+    let duration = start_time.elapsed();
+    println!(
+        "Successfully found vanity address in {:.3} seconds.\n",
+        duration.as_secs_f64()
+    );
+
+    let checksum_address = checksum_encode(&address.to_string())?;
+    let result = if let Some(mnemonic) = mnemonic {
+        json!({
+            "Address": checksum_address,
+            "PrivateKey": hex::encode(secret_key.as_ref()),
+            "Mnemonic": mnemonic,
+        })
+    } else {
+        json!({
+            "Address": checksum_address,
+            "PrivateKey": hex::encode(secret_key.as_ref()),
+        })
+    };
+
+    if let Some(path) = save_path {
+        std::fs::write(path, serde_json::to_string_pretty(&result)?)?;
+    }
+
+    Ok(result)
+}
+
+pub trait VanityMatcher: Send + Sync + 'static {
+    fn is_match(&self, addr: &Address) -> bool;
+}
+
+pub struct HexMatcher {
+    prefix: String,
+    suffix: String,
+}
+
+impl HexMatcher {
+    pub fn new(prefix: &str, suffix: &str) -> anyhow::Result<Self> {
+        Ok(Self {
+            prefix: prefix.to_lowercase(),
+            suffix: suffix.to_lowercase(),
+        })
+    }
+}
+
+impl VanityMatcher for HexMatcher {
+    fn is_match(&self, addr: &Address) -> bool {
+        let hex_addr = hex::encode(addr.as_ref()).to_lowercase();
+        hex_addr.starts_with(&self.prefix) && hex_addr.ends_with(&self.suffix)
+    }
+}
+
+pub struct RegexMatcher {
+    re: Regex,
+}
+
+impl RegexMatcher {
+    pub fn new(pattern: &str) -> anyhow::Result<Self> {
+        let re = Regex::new(&format!("(?i){}", pattern))?;
+        Ok(Self { re })
+    }
+}
+
+impl VanityMatcher for RegexMatcher {
+    fn is_match(&self, addr: &Address) -> bool {
+        let addr = hex::encode(addr.as_ref());
+        self.re.is_match(&addr)
+    }
+}
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+pub fn find_vanity_address_with_timeout(
+    matcher: Either<RegexMatcher, HexMatcher>,
+    use_mnemonic: bool,
+    timeout_secs: Option<u64>,
+) -> anyhow::Result<(Address, SecretKey, Option<String>)> {
+    let should_stop = Arc::new(AtomicBool::new(false));
+    let should_stop_clone = should_stop.clone();
+
+    let generate_wallet = move || {
+        let breakpoint = if use_mnemonic { 1_000 } else { 100_000 };
+        let start = Instant::now();
+        let attempts = std::sync::atomic::AtomicUsize::new(0);
+
+        wallet_generator(use_mnemonic)
+            .find_any(|result| {
+                // Check if we should stop due to timeout
+                if should_stop.load(Ordering::Relaxed) {
+                    return true; // This will cause find_any to return the current result
+                }
+
+                let current = attempts.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                if current != 0 && current % breakpoint == 0 {
+                    let elapsed = start.elapsed().as_secs_f64();
+                    let rate = current as f64 / elapsed;
+                    println!(
+                        "└─ tried {} addresses ({:.2} addresses/sec)...",
+                        current, rate
+                    );
+                }
+
+                if let Ok((addr, _, _)) = result {
+                    match &matcher {
+                        Either::Left(regex_matcher) => regex_matcher.is_match(addr),
+                        Either::Right(hex_matcher) => hex_matcher.is_match(addr),
+                    }
+                } else {
+                    false
+                }
+            })
+            .ok_or_else(|| anyhow::anyhow!("No matching address found"))?
+    };
+
+    let Some(secs) = timeout_secs else {
+        return generate_wallet();
+    };
+
+    Runtime::new()?.block_on(async {
+        let generation_task = tokio::task::spawn_blocking(generate_wallet);
+
+        tokio::select! {
+            result = generation_task => {
+                match result {
+                    Ok(wallet_result) => wallet_result,
+                    Err(_) => Err(anyhow::anyhow!("No matching address found")),
+                }
+            }
+            _ = tokio::time::sleep(Duration::from_secs(secs)) => {
+                // Signal all threads to stop
+                should_stop_clone.store(true, Ordering::Relaxed);
+                // Wait a short time for threads to notice the stop signal
+                tokio::time::sleep(Duration::from_millis(100)).await;
+                Err(anyhow::anyhow!("Vanity address generation timed out after {} seconds", secs))
+            }
+        }
+    })
+}
+
+#[inline]
+fn wallet_generator(
+    use_mnemonic: bool,
+) -> impl ParallelIterator<Item = anyhow::Result<(Address, SecretKey, Option<String>)>> {
+    iter::repeat(()).map(move |()| generate_wallet(use_mnemonic))
+}
+
+fn generate_wallet(use_mnemonic: bool) -> anyhow::Result<(Address, SecretKey, Option<String>)> {
+    let mut rng = rand::thread_rng();
+
+    let (private_key, mnemonic) = if use_mnemonic {
+        let mnemonic = generate_mnemonic_phrase(&mut rng, 24)?;
+        let account_ix = 0;
+        let derivation_path = format!("{DEFAULT_DERIVATION_PATH_PREFIX}/{account_ix}'/0/0");
+        let private_key =
+            SecretKey::new_from_mnemonic_phrase_with_path(&mnemonic, &derivation_path)?;
+        (private_key, Some(mnemonic))
+    } else {
+        (SecretKey::random(&mut rng), None)
+    };
+
+    let public = PublicKey::from(&private_key);
+    let hashed = public.hash();
+    let address = Bech32Address::new(FUEL_BECH32_HRP, hashed);
+
+    Ok((address.into(), private_key, mnemonic))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+
+    // Helper function to parse args and get validation errors
+    fn parse_args(args: Vec<&str>) -> Result<Arg, String> {
+        let args =
+            Arg::try_parse_from(std::iter::once("test").chain(args)).map_err(|e| e.to_string())?;
+        args.validate().map_err(|e| e.to_string())?;
+        Ok(args)
+    }
+
+    #[test]
+    fn test_invalid_hex_characters() {
+        let result = parse_args(vec!["--starts-with", "xyz"]);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "error: invalid value 'xyz' for '--starts-with <HEX_STRING>': Pattern must contain only hex characters (0-9, a-f)\n\nFor more information, try '--help'.\n");
+    }
+
+    #[test]
+    fn test_pattern_too_long() {
+        let result = parse_args(vec![
+            "--starts-with",
+            &"a".repeat(32),
+            "--ends-with",
+            &"b".repeat(33),
+        ]);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            "Combined pattern length exceeds 64 characters"
+        );
+    }
+
+    #[test]
+    fn test_invalid_regex_syntax() {
+        let result = parse_args(vec!["--regex", "["]);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "error: invalid value '[' for '--regex <PATTERN>': Invalid regex pattern: regex parse error:\n    (?i)[\n        ^\nerror: unclosed character class\n\nFor more information, try '--help'.\n");
+    }
+
+    #[test]
+    fn test_regex_too_long() {
+        let result = parse_args(vec!["--regex", &"a".repeat(129)]);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "error: invalid value 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' for '--regex <PATTERN>': Regex pattern too long: max 128 characters\n\nFor more information, try '--help'.\n");
+    }
+
+    #[test]
+    fn test_conflicting_args() {
+        let result = parse_args(vec!["--starts-with", "aa", "--regex", "^aa"]);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "error: the argument '--starts-with <HEX_STRING>' cannot be used with '--regex <PATTERN>'\n\nUsage: test --starts-with <HEX_STRING>\n\nFor more information, try '--help'.\n");
+    }
+
+    #[test]
+    fn test_timeout_respected() {
+        // This pattern should take a long time to generate
+        let args = parse_args(vec!["--starts-with", "fffffffffffff", "--timeout", "1"]).unwrap();
+
+        let result = handler(args);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Vanity address generation timed out after 1 seconds"
+        );
+    }
+
+    // Test actual functionality with minimal patterns
+    #[test]
+    fn test_valid_short_prefix() {
+        let args = parse_args(vec!["--starts-with", "a"]).unwrap();
+        let result = handler(args).unwrap();
+        let address = result["Address"].as_str().unwrap();
+        assert!(
+            address.to_lowercase().starts_with("0xa"),
+            "Address should start with 'a'"
+        );
+    }
+
+    #[test]
+    fn test_valid_short_suffix() {
+        let args = parse_args(vec!["--ends-with", "a"]).unwrap();
+        let result = handler(args).unwrap();
+        let address = result["Address"].as_str().unwrap();
+        assert!(
+            address.to_lowercase().ends_with('a'),
+            "Address should end with 'a'"
+        );
+    }
+
+    #[test]
+    fn test_both_prefix_and_suffix() {
+        let args = parse_args(vec!["--starts-with", "a", "--ends-with", "b"]).unwrap();
+        let result = handler(args).unwrap();
+        let address = result["Address"].as_str().unwrap().to_lowercase();
+        assert!(address.starts_with("0xa"), "Address should start with 'a'");
+        assert!(address.ends_with('b'), "Address should end with 'b'");
+    }
+
+    #[test]
+    fn test_simple_regex() {
+        let args = parse_args(vec!["--regex", "^a.*b$"]).unwrap();
+        let result = handler(args).unwrap();
+        let address = result["Address"].as_str().unwrap().to_lowercase();
+        assert!(address.starts_with("0xa"), "Address should start with 'a'");
+        assert!(address.ends_with('b'), "Address should end with 'b'");
+    }
+
+    #[test]
+    fn test_simple_regex_uppercase() {
+        let args = parse_args(vec!["--regex", "^A.*B$"]).unwrap();
+        let result = handler(args).unwrap();
+        let address = result["Address"].as_str().unwrap().to_lowercase();
+        assert!(address.starts_with("0xa"), "Address should start with 'a'");
+        assert!(address.ends_with('b'), "Address should end with 'b'");
+    }
+
+    #[test]
+    fn test_mnemonic_generation() {
+        let args = parse_args(vec!["--starts-with", "a", "--mnemonic"]).unwrap();
+        let result = handler(args).unwrap();
+
+        assert!(result["Mnemonic"].is_string(), "Mnemonic should be present");
+        assert_eq!(
+            result["Mnemonic"]
+                .as_str()
+                .unwrap()
+                .split_whitespace()
+                .count(),
+            24,
+            "Mnemonic should have 24 words"
+        );
+
+        let address = result["Address"].as_str().unwrap();
+        assert!(
+            address.to_lowercase().starts_with("0xa"),
+            "Address should start with 'a'"
+        );
+    }
+
+    #[test]
+    fn test_save_path() {
+        let tmp = tempfile::NamedTempFile::new().unwrap();
+        let args = parse_args(vec![
+            "--starts-with",
+            "a",
+            "--save-path",
+            tmp.path().to_str().unwrap(),
+        ])
+        .unwrap();
+
+        handler(args).unwrap();
+
+        assert!(tmp.path().exists(), "File should exist");
+        let content = std::fs::read_to_string(tmp.path()).unwrap();
+        let saved_result: serde_json::Value = serde_json::from_str(&content).unwrap();
+        assert!(
+            saved_result["Address"].is_string(),
+            "Saved result should contain an Address"
+        );
+        assert!(
+            saved_result["PrivateKey"].is_string(),
+            "Saved result should contain a PrivateKey"
+        );
+    }
+}
diff --git a/forc-plugins/forc-crypto/src/lib.rs b/forc-plugins/forc-crypto/src/lib.rs
new file mode 100644
index 00000000000..7c89d848120
--- /dev/null
+++ b/forc-plugins/forc-crypto/src/lib.rs
@@ -0,0 +1,37 @@
+pub mod address;
+pub mod args;
+pub mod keccak256;
+pub mod keys;
+pub mod sha256;
+
+pub(crate) fn help() -> &'static str {
+    Box::leak(
+        format!(
+            "EXAMPLES:\n{}{}{}{}{}{}",
+            args::examples(),
+            address::examples(),
+            keys::new_key::examples(),
+            keys::parse_secret::examples(),
+            keys::get_public_key::examples(),
+            keys::vanity::examples(),
+        )
+        .into_boxed_str(),
+    )
+}
+
+/// Forc plugin for hashing arbitrary data
+#[derive(Debug, clap::Parser)]
+#[clap(
+    name = "forc-crypto",
+    after_help = help(),
+    version
+)]
+pub enum Command {
+    Keccak256(args::HashArgs),
+    Sha256(args::HashArgs),
+    Address(address::Args),
+    GetPublicKey(keys::get_public_key::Arg),
+    NewKey(keys::new_key::Arg),
+    ParseSecret(keys::parse_secret::Arg),
+    Vanity(keys::vanity::Arg),
+}
diff --git a/forc-plugins/forc-crypto/src/main.rs b/forc-plugins/forc-crypto/src/main.rs
index fba619b2b59..c9ae55b23f0 100644
--- a/forc-plugins/forc-crypto/src/main.rs
+++ b/forc-plugins/forc-crypto/src/main.rs
@@ -3,6 +3,7 @@
 use anyhow::Result;
 use atty::Stream;
 use clap::Parser;
+use forc_crypto::{address, keccak256, keys, sha256, Command};
 use forc_tracing::{init_tracing_subscriber, println_error};
 use std::{
     default::Default,
@@ -10,42 +11,6 @@ use std::{
 };
 use termion::screen::IntoAlternateScreen;
 
-mod address;
-mod args;
-mod keccak256;
-mod keys;
-mod sha256;
-
-fn help() -> &'static str {
-    Box::leak(
-        format!(
-            "EXAMPLES:\n{}{}{}{}{}",
-            args::examples(),
-            address::examples(),
-            keys::new_key::examples(),
-            keys::parse_secret::examples(),
-            keys::get_public_key::examples(),
-        )
-        .into_boxed_str(),
-    )
-}
-
-/// Forc plugin for hashing arbitrary data
-#[derive(Debug, Parser)]
-#[clap(
-    name = "forc-crypto",
-    after_help = help(),
-    version
-)]
-pub enum Command {
-    Keccak256(args::HashArgs),
-    Sha256(args::HashArgs),
-    Address(address::Args),
-    GetPublicKey(keys::get_public_key::Arg),
-    NewKey(keys::new_key::Arg),
-    ParseSecret(keys::parse_secret::Arg),
-}
-
 fn main() {
     init_tracing_subscriber(Default::default());
     if let Err(err) = run() {
@@ -59,6 +24,7 @@ fn run() -> Result<()> {
     let content = match app {
         Command::Keccak256(arg) => keccak256::hash(arg)?,
         Command::GetPublicKey(arg) => keys::get_public_key::handler(arg)?,
+        Command::Vanity(arg) => keys::vanity::handler(arg)?,
         Command::Sha256(arg) => sha256::hash(arg)?,
         Command::Address(arg) => address::dump_address(arg.address)?,
         Command::NewKey(arg) => keys::new_key::handler(arg)?,
@@ -83,7 +49,7 @@ where
     }
 }
 
-pub(crate) fn display_output<T>(message: T) -> anyhow::Result<()>
+pub fn display_output<T>(message: T) -> anyhow::Result<()>
 where
     T: serde::Serialize,
 {
diff --git a/forc-plugins/forc-debug/Cargo.toml b/forc-plugins/forc-debug/Cargo.toml
index 604cb8134ba..4911d214c2e 100644
--- a/forc-plugins/forc-debug/Cargo.toml
+++ b/forc-plugins/forc-debug/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-debug"
-version = "0.60.0"
+version.workspace = true
 description = "Supports debugging Sway code via CLI and DAP server."
 authors.workspace = true
 edition.workspace = true
@@ -9,25 +9,26 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1.0" # Used by the examples and for conversion only
-clap = { version = "4.5.4", features = ["derive", "env"] }
-dap = "0.4.1-alpha1"
-forc-pkg = { version = "0.60.0", path = "../../forc-pkg" }
-forc-test = { version = "0.60.0", path = "../../forc-test" }
-fuel-core-client = { workspace = true }
+anyhow.workspace = true
+clap = { workspace = true, features = ["derive", "env"] }
+dap.workspace = true
+forc-pkg.workspace = true
+forc-test.workspace = true
+forc-tracing.workspace = true
+fuel-core-client.workspace = true
 fuel-types = { workspace = true, features = ["serde"] }
 fuel-vm = { workspace = true, features = ["serde"] }
-rayon = "1.7.0"
-serde = "1.0"
-serde_json = "1.0"
-shellfish = { version = "0.6.0", features = ["rustyline", "async", "tokio"] }
-sway-core = { version = "0.60.0", path = "../../sway-core" }
-sway-types = { version = "0.60.0", path = "../../sway-types" }
-thiserror = "1.0"
-tokio = { version = "1.8", features = [
-    "net",
+rayon.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+shellfish = { workspace = true, features = ["async", "rustyline", "tokio"] }
+sway-core.workspace = true
+sway-types.workspace = true
+thiserror.workspace = true
+tokio = { workspace = true, features = [
     "io-util",
     "macros",
+    "net",
     "rt-multi-thread",
 ] }
 
diff --git a/forc-plugins/forc-debug/src/main.rs b/forc-plugins/forc-debug/src/main.rs
index a3a452baa95..7bf6a13b81a 100644
--- a/forc-plugins/forc-debug/src/main.rs
+++ b/forc-plugins/forc-debug/src/main.rs
@@ -4,6 +4,7 @@ use forc_debug::{
     server::DapServer,
     ContractId, FuelClient, RunResult, Transaction,
 };
+use forc_tracing::{init_tracing_subscriber, println_error};
 use fuel_vm::consts::{VM_MAX_RAM, VM_REGISTER_COUNT, WORD_SIZE};
 use shellfish::{async_fn, Command as ShCommand, Shell};
 use std::error::Error;
@@ -21,9 +22,17 @@ pub struct Opt {
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() {
+    init_tracing_subscriber(Default::default());
     let config = Opt::parse();
 
+    if let Err(err) = run(&config).await {
+        println_error(&format!("{}", err));
+        std::process::exit(1);
+    }
+}
+
+async fn run(config: &Opt) -> Result<(), Box<dyn std::error::Error>> {
     if config.serve {
         return DapServer::default().start();
     }
@@ -123,7 +132,7 @@ async fn cmd_start_tx(state: &mut State, mut args: Vec<String>) -> Result<(), Bo
     }
 
     let tx_json = std::fs::read(path_to_tx_json)?;
-    let tx: Transaction = serde_json::from_slice(&tx_json).unwrap();
+    let tx: Transaction = serde_json::from_slice(&tx_json)?;
     let status = state.client.start_tx(&state.session_id, &tx).await?;
     pretty_print_run_result(&status);
 
diff --git a/forc-plugins/forc-debug/src/server/handlers/handle_set_breakpoints.rs b/forc-plugins/forc-debug/src/server/handlers/handle_set_breakpoints.rs
index af08e198ac3..63390fb458e 100644
--- a/forc-plugins/forc-debug/src/server/handlers/handle_set_breakpoints.rs
+++ b/forc-plugins/forc-debug/src/server/handlers/handle_set_breakpoints.rs
@@ -43,7 +43,7 @@ impl DapServer {
             .unwrap_or_default()
             .iter()
             .map(|source_bp| {
-                let verified = source_map.get(&source_bp.line).is_some();
+                let verified = source_map.contains_key(&source_bp.line);
 
                 match existing_breakpoints.iter().find(|bp| match bp.line {
                     Some(line) => line == source_bp.line,
diff --git a/forc-plugins/forc-doc/Cargo.toml b/forc-plugins/forc-doc/Cargo.toml
index 2df059d920b..e6780e0fe80 100644
--- a/forc-plugins/forc-doc/Cargo.toml
+++ b/forc-plugins/forc-doc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-doc"
-version = "0.60.0"
+version.workspace = true
 description = "Build the documentation for the local package and all dependencies. The output is placed in `out/doc` in the same format as the project."
 authors.workspace = true
 edition.workspace = true
@@ -9,23 +9,23 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1.0.65"
-clap = { version = "4.5.4", features = ["derive"] }
-colored = "2.0.0"
-comrak = "0.16"
-forc-pkg = { version = "0.60.0", path = "../../forc-pkg" }
-forc-util = { version = "0.60.0", path = "../../forc-util" }
-horrorshow = "0.8.4"
-include_dir = "0.7.3"
-minifier = "0.3.0"
-opener = "0.5.0"
-serde = "1.0"
-serde_json = "1.0"
-sway-ast = { version = "0.60.0", path = "../../sway-ast" }
-sway-core = { version = "0.60.0", path = "../../sway-core" }
-sway-lsp = { version = "0.60.0", path = "../../sway-lsp" }
-sway-types = { version = "0.60.0", path = "../../sway-types" }
-swayfmt = { version = "0.60.0", path = "../../swayfmt" }
+anyhow.workspace = true
+clap = { workspace = true, features = ["derive"] }
+comrak.workspace = true
+forc-pkg.workspace = true
+forc-tracing.workspace = true
+forc-util.workspace = true
+horrorshow.workspace = true
+include_dir.workspace = true
+minifier.workspace = true
+opener.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sway-ast.workspace = true
+sway-core.workspace = true
+sway-lsp.workspace = true
+sway-types.workspace = true
+swayfmt.workspace = true
 
 [dev-dependencies]
 dir_indexer = "0.0.2"
diff --git a/forc-plugins/forc-doc/src/doc/mod.rs b/forc-plugins/forc-doc/src/doc/mod.rs
index 384939a2964..f407eefead7 100644
--- a/forc-plugins/forc-doc/src/doc/mod.rs
+++ b/forc-plugins/forc-doc/src/doc/mod.rs
@@ -15,7 +15,7 @@ use std::{
 };
 use sway_core::{
     decl_engine::DeclEngine,
-    language::ty::{TyAstNodeContent, TyDecl, TyImplTrait, TyModule, TyProgram, TySubmodule},
+    language::ty::{TyAstNodeContent, TyDecl, TyImplSelfOrTrait, TyModule, TyProgram, TySubmodule},
     Engines,
 };
 use sway_types::BaseIdent;
@@ -36,7 +36,7 @@ impl Documentation {
     ) -> Result<Documentation> {
         // the first module prefix will always be the project name
         let mut docs = Documentation::default();
-        let mut impl_traits: Vec<(TyImplTrait, ModuleInfo)> = Vec::new();
+        let mut impl_traits: Vec<(TyImplSelfOrTrait, ModuleInfo)> = Vec::new();
         let module_info = ModuleInfo::from_ty_module(vec![project_name.to_owned()], None);
         Documentation::from_ty_module(
             engines.de(),
@@ -144,14 +144,14 @@ impl Documentation {
         module_info: &ModuleInfo,
         ty_module: &TyModule,
         docs: &mut Documentation,
-        impl_traits: &mut Vec<(TyImplTrait, ModuleInfo)>,
+        impl_traits: &mut Vec<(TyImplSelfOrTrait, ModuleInfo)>,
         document_private_items: bool,
     ) -> Result<()> {
         for ast_node in &ty_module.all_nodes {
             if let TyAstNodeContent::Declaration(ref decl) = ast_node.content {
-                if let TyDecl::ImplTrait(impl_trait) = decl {
+                if let TyDecl::ImplSelfOrTrait(impl_trait) = decl {
                     impl_traits.push((
-                        (*decl_engine.get_impl_trait(&impl_trait.decl_id)).clone(),
+                        (*decl_engine.get_impl_self_or_trait(&impl_trait.decl_id)).clone(),
                         module_info.clone(),
                     ));
                 } else {
@@ -175,7 +175,7 @@ impl Documentation {
         decl_engine: &DeclEngine,
         typed_submodule: &TySubmodule,
         docs: &mut Documentation,
-        impl_traits: &mut Vec<(TyImplTrait, ModuleInfo)>,
+        impl_traits: &mut Vec<(TyImplSelfOrTrait, ModuleInfo)>,
         module_info: &ModuleInfo,
         document_private_items: bool,
     ) -> Result<()> {
diff --git a/forc-plugins/forc-doc/src/lib.rs b/forc-plugins/forc-doc/src/lib.rs
index 5369d5b327f..d629b606563 100644
--- a/forc-plugins/forc-doc/src/lib.rs
+++ b/forc-plugins/forc-doc/src/lib.rs
@@ -6,13 +6,13 @@ pub mod tests;
 
 use anyhow::{bail, Result};
 use cli::Command;
-use colored::Colorize;
 use doc::Documentation;
 use forc_pkg as pkg;
 use forc_pkg::{
     manifest::{GenericManifestFile, ManifestFile},
     PackageManifestFile,
 };
+use forc_tracing::println_action_green;
 use forc_util::default_output_directory;
 use render::RenderedDocumentation;
 use std::{
@@ -77,11 +77,13 @@ pub fn compile_html(
     }
     fs::create_dir_all(&doc_path)?;
 
-    println!(
-        "   {} {} ({})",
-        "Compiling".bold().yellow(),
-        pkg_manifest.project_name(),
-        manifest.dir().to_string_lossy()
+    println_action_green(
+        "Compiling",
+        &format!(
+            "{} ({})",
+            pkg_manifest.project_name(),
+            manifest.dir().to_string_lossy()
+        ),
     );
 
     let member_manifests = manifest.member_manifests()?;
@@ -179,11 +181,13 @@ fn build_docs(
         pkg_manifest,
     } = program_info;
 
-    println!(
-        "    {} documentation for {} ({})",
-        "Building".bold().yellow(),
-        pkg_manifest.project_name(),
-        manifest.dir().to_string_lossy()
+    println_action_green(
+        "Building",
+        &format!(
+            "documentation for {} ({})",
+            pkg_manifest.project_name(),
+            manifest.dir().to_string_lossy()
+        ),
     );
 
     let raw_docs = Documentation::from_ty_program(
@@ -210,7 +214,7 @@ fn build_docs(
 
     // write file contents to doc folder
     write_content(rendered_docs, doc_path)?;
-    println!("    {}", "Finished".bold().yellow());
+    println_action_green("Finished", pkg_manifest.project_name());
 
     Ok(raw_docs)
 }
diff --git a/forc-plugins/forc-doc/src/render/item/context.rs b/forc-plugins/forc-doc/src/render/item/context.rs
index a5720ea1394..3e4a49cc29f 100644
--- a/forc-plugins/forc-doc/src/render/item/context.rs
+++ b/forc-plugins/forc-doc/src/render/item/context.rs
@@ -16,7 +16,7 @@ use anyhow::Result;
 use horrorshow::{box_html, Raw, RenderBox, Template};
 use std::{collections::BTreeMap, fmt::Write};
 use sway_core::language::ty::{
-    TyEnumVariant, TyImplTrait, TyStorageField, TyStructField, TyTraitFn, TyTraitItem,
+    TyEnumVariant, TyImplSelfOrTrait, TyStorageField, TyStructField, TyTraitFn, TyTraitItem,
 };
 
 /// The actual context of the item displayed by [ItemContext].
@@ -268,7 +268,7 @@ impl Renderable for Context {
 #[derive(Debug, Clone)]
 pub struct DocImplTrait {
     pub impl_for_module: ModuleInfo,
-    pub impl_trait: TyImplTrait,
+    pub impl_trait: TyImplSelfOrTrait,
     pub module_info_override: Option<Vec<String>>,
 }
 
@@ -495,7 +495,7 @@ impl Renderable for ItemContext {
 }
 impl Renderable for DocImplTrait {
     fn render(self, render_plan: RenderPlan) -> Result<Box<dyn RenderBox>> {
-        let TyImplTrait {
+        let TyImplSelfOrTrait {
             trait_name,
             items,
             implementing_for,
diff --git a/forc-plugins/forc-doc/src/render/item/type_anchor.rs b/forc-plugins/forc-doc/src/render/item/type_anchor.rs
index 17bc2de06c2..514d7f6dcd2 100644
--- a/forc-plugins/forc-doc/src/render/item/type_anchor.rs
+++ b/forc-plugins/forc-doc/src/render/item/type_anchor.rs
@@ -3,7 +3,7 @@ use crate::{doc::module::ModuleInfo, RenderPlan};
 use anyhow::{anyhow, Result};
 use horrorshow::{box_html, RenderBox};
 use sway_core::{AbiName, TypeInfo};
-use sway_types::Spanned;
+use sway_types::{Named, Spanned};
 
 /// Handles types & nested types that should have links
 /// eg. (`[]` represent types with links).
@@ -33,6 +33,18 @@ pub(crate) fn render_type_anchor(
                 : format!("; {}]", len.val());
             })
         }
+        TypeInfo::Slice(ty_arg) => {
+            let inner = render_type_anchor(
+                (*render_plan.engines.te().get(ty_arg.type_id)).clone(),
+                render_plan,
+                current_module_info,
+            )?;
+            Ok(box_html! {
+                : "__slice[";
+                : inner;
+                : "]";
+            })
+        }
         TypeInfo::Tuple(ty_args) => {
             let mut rendered_args: Vec<_> = Vec::new();
             for ty_arg in ty_args {
@@ -50,38 +62,38 @@ pub(crate) fn render_type_anchor(
                 : ")";
             })
         }
-        TypeInfo::Enum(decl_ref) => {
-            let enum_decl = render_plan.engines.de().get_enum(&decl_ref);
+        TypeInfo::Enum(decl_id) => {
+            let enum_decl = render_plan.engines.de().get_enum(&decl_id);
             if !render_plan.document_private_items && enum_decl.visibility.is_private() {
                 Ok(box_html! {
-                    : decl_ref.name().clone().as_str();
+                    : enum_decl.name().clone().as_str();
                 })
             } else {
                 let module_info = ModuleInfo::from_call_path(&enum_decl.call_path);
-                let file_name = format!("enum.{}.html", decl_ref.name().clone().as_str());
+                let file_name = format!("enum.{}.html", enum_decl.name().clone().as_str());
                 let href =
                     module_info.file_path_from_location(&file_name, current_module_info, false)?;
                 Ok(box_html! {
                     a(class="enum", href=href) {
-                        : decl_ref.name().clone().as_str();
+                        : enum_decl.name().clone().as_str();
                     }
                 })
             }
         }
-        TypeInfo::Struct(decl_ref) => {
-            let struct_decl = render_plan.engines.de().get_struct(&decl_ref);
+        TypeInfo::Struct(decl_id) => {
+            let struct_decl = render_plan.engines.de().get_struct(&decl_id);
             if !render_plan.document_private_items && struct_decl.visibility.is_private() {
                 Ok(box_html! {
-                    : decl_ref.name().clone().as_str();
+                    : struct_decl.name().clone().as_str();
                 })
             } else {
                 let module_info = ModuleInfo::from_call_path(&struct_decl.call_path);
-                let file_name = format!("struct.{}.html", decl_ref.name().clone().as_str());
+                let file_name = format!("struct.{}.html", struct_decl.name().clone().as_str());
                 let href =
                     module_info.file_path_from_location(&file_name, current_module_info, false)?;
                 Ok(box_html! {
                     a(class="struct", href=href) {
-                        : decl_ref.name().clone().as_str();
+                        : struct_decl.name().clone().as_str();
                     }
                 })
             }
diff --git a/forc-plugins/forc-doc/src/render/search.rs b/forc-plugins/forc-doc/src/render/search.rs
index e0f84216ebe..9213c17210d 100644
--- a/forc-plugins/forc-doc/src/render/search.rs
+++ b/forc-plugins/forc-doc/src/render/search.rs
@@ -25,10 +25,10 @@ pub(crate) fn generate_searchbar(module_info: &ModuleInfo) -> Box<dyn RenderBox>
             const searchbar = document.getElementById("search-input");
             const searchForm = document.getElementById("search-form");
             searchbar.addEventListener("keyup", function(event) {{
-                searchForm.dispatchEvent(new Event('submit'));
+                onSearchFormSubmit(event);
             }});
             searchbar.addEventListener("search", function(event) {{
-                searchForm.dispatchEvent(new Event('submit'));
+                onSearchFormSubmit(event);
             }});
         
             function onQueryParamsChange() {{
diff --git a/forc-plugins/forc-doc/src/render/title.rs b/forc-plugins/forc-doc/src/render/title.rs
index ee4b1a44271..26dcc1e85fd 100644
--- a/forc-plugins/forc-doc/src/render/title.rs
+++ b/forc-plugins/forc-doc/src/render/title.rs
@@ -119,7 +119,7 @@ impl DocBlock for TyDecl {
             TyDecl::TraitDecl(_) => "trait",
             TyDecl::AbiDecl(_) => "abi",
             TyDecl::StorageDecl(_) => "contract_storage",
-            TyDecl::ImplTrait(_) => "impl_trait",
+            TyDecl::ImplSelfOrTrait(_) => "impl_trait",
             TyDecl::FunctionDecl(_) => "fn",
             TyDecl::ConstantDecl(_) => "constant",
             TyDecl::TypeAliasDecl(_) => "type_alias",
diff --git a/forc-plugins/forc-doc/src/tests/expects/impl_trait/mod.rs b/forc-plugins/forc-doc/src/tests/expects/impl_trait/mod.rs
index 5ab755043de..8f96a41e856 100644
--- a/forc-plugins/forc-doc/src/tests/expects/impl_trait/mod.rs
+++ b/forc-plugins/forc-doc/src/tests/expects/impl_trait/mod.rs
@@ -37,15 +37,14 @@ fn test_impl_traits_default() {
     assert_index_html(
         &doc_path,
         project_name,
-        &expect![[
-            r##"<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="swaydoc"><meta name="description" content="API documentation for the Sway `Bar` struct in `bar`."><meta name="keywords" content="sway, swaylang, sway-lang, Bar"><link rel="icon" href="../../static.files/sway-logo.svg"><title>Bar in bar - Sway</title><link rel="stylesheet" type="text/css" href="../../static.files/normalize.css"><link rel="stylesheet" type="text/css" href="../../static.files/swaydoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../static.files/ayu.css"><link rel="stylesheet" href="../../static.files/ayu.min.css"></head><body class="swaydoc struct"><nav class="sidebar"><a class="sidebar-logo" href="../../impl_traits/index.html"><div class="logo-container"><img class="sway-logo" src="../../static.files/sway-logo.svg" alt="logo"></div></a><h2 class="location">Struct Bar</h2><div class="sidebar-elems"><section><h3><a href="#methods">Methods</a></h3><ul class="block method"><li><a href="#method.foo_bar">foo_bar</a></li></ul></section><section><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block method"><li><a href="#impl-Foo">Foo</a></li><li><a href="#impl-Baz">Baz</a></li><li><a href="#impl-Add">Add</a></li><li><a href="#impl-Subtract">Subtract</a></li></ul></section></div></nav><main><div class="width-limiter"><script src="../../search.js" type="text/javascript"></script><script>function onSearchFormSubmit(event){event.preventDefault();const searchQuery=document.getElementById("search-input").value;const url=new URL(window.location.href);if(searchQuery){url.searchParams.set('search',searchQuery)}else{url.searchParams.delete('search')}history.pushState({search:searchQuery},"",url);window.dispatchEvent(new HashChangeEvent("hashchange"))}document.addEventListener('DOMContentLoaded',()=>{const searchbar=document.getElementById("search-input");const searchForm=document.getElementById("search-form");searchbar.addEventListener("keyup",function(event){searchForm.dispatchEvent(new Event('submit'))});searchbar.addEventListener("search",function(event){searchForm.dispatchEvent(new Event('submit'))});function onQueryParamsChange(){const searchParams=new URLSearchParams(window.location.search);const query=searchParams.get("search");const searchSection=document.getElementById('search');const mainSection=document.getElementById('main-content');const searchInput=document.getElementById('search-input');if(query){searchInput.value=query;const results=Object.values(SEARCH_INDEX).flat().filter(item=>{const lowerQuery=query.toLowerCase();return item.name.toLowerCase().includes(lowerQuery)});const header=`<h1>Results for ${query}</h1>`;if(results.length>0){const resultList=results.map(item=>{const formattedName=`<span class="type ${item.type_name}">${item.name}</span>`;const name=[...item.module_info,formattedName].join("::");const path=["../..",...item.module_info,item.html_filename].join("/");const left=`<td><span>${name}</span></td>`;const right=`<td><p>${item.preview}</p></td>`;return`<tr onclick="window.location='${path}';">${left}${right}</tr>`}).join('');searchSection.innerHTML=`${header}<table>${resultList}</table>`}else{searchSection.innerHTML=`${header}<p>No results found.</p>`}searchSection.setAttribute("class","search-results");mainSection.setAttribute("class","content hidden")}else{searchSection.setAttribute("class","search-results hidden");mainSection.setAttribute("class","content")}}window.addEventListener('hashchange',onQueryParamsChange);onQueryParamsChange()})</script><nav class="sub"><form id="search-form" class="search-form" onsubmit="onSearchFormSubmit(event)"><div class="search-container"><input id="search-input" class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Search the docs..." type="search"></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1 class="fqn"><span class="in-band">Struct <a class="mod" href="../index.html">impl_traits</a><span>::</span><a class="mod" href="index.html">bar</a><span>::</span><a class="struct" href="#">Bar</a></span></h1></div><div class="docblock item-decl"><pre class="sway struct"><code>pub struct Bar {}</code></pre></div><h2 id="methods" class="small-section-header">Implementations<a href="#methods" class="anchor"></a></h2><div id="methods-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Bar" class="impl has-srclink"><a href="#impl-Bar" class="anchor"></a><h3 class="code-header in-band">impl Bar</h3></div></summary><div class="impl-items"><div id="method.foo_bar" class="method trait-impl"><a href="#method.foo_bar" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo_bar">foo_bar</a>()</h4></div></div></details></div><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Foo" class="impl has-srclink"><a href="#impl-Foo" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Foo.html">Foo</a> for Bar</h3></div></summary><div class="impl-items"><details class="swaydoc-toggle method-toggle" open><summary><div id="method.foo" class="method trait-impl"><a href="#method.foo" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo">foo</a>()</h4></div></summary><div class="docblock"><p>something more about foo();</p>
-</div></details></div></details><div id="impl-Baz" class="impl has-srclink"><a href="#impl-Baz" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Baz.html">Baz</a> for Bar</h3></div><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Add" class="impl has-srclink"><a href="#impl-Add" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../../core/ops/trait.Add.html">Add</a> for Bar</h3></div></summary><div class="impl-items"><div id="method.add" class="method trait-impl"><a href="#method.add" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.add">add</a>(self, other: Self) -&gt; Self</h4></div></div></details><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Subtract" class="impl has-srclink"><a href="#impl-Subtract" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../../core/ops/trait.Subtract.html">Subtract</a> for Bar</h3></div></summary><div class="impl-items"><div id="method.subtract" class="method trait-impl"><a href="#method.subtract" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.subtract">subtract</a>(self, other: Self) -&gt; Self</h4></div></div></details></div></section><section id="search" class="search-results"></section></div></main><script src="../../static.files/highlight.js"></script><script>hljs.highlightAll();</script></body></html>"##
-        ]],
+        &expect![[r##"
+    <!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="swaydoc"><meta name="description" content="API documentation for the Sway `Bar` struct in `bar`."><meta name="keywords" content="sway, swaylang, sway-lang, Bar"><link rel="icon" href="../../static.files/sway-logo.svg"><title>Bar in bar - Sway</title><link rel="stylesheet" type="text/css" href="../../static.files/normalize.css"><link rel="stylesheet" type="text/css" href="../../static.files/swaydoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../static.files/ayu.css"><link rel="stylesheet" href="../../static.files/ayu.min.css"></head><body class="swaydoc struct"><nav class="sidebar"><a class="sidebar-logo" href="../../impl_traits/index.html"><div class="logo-container"><img class="sway-logo" src="../../static.files/sway-logo.svg" alt="logo"></div></a><h2 class="location">Struct Bar</h2><div class="sidebar-elems"><section><h3><a href="#methods">Methods</a></h3><ul class="block method"><li><a href="#method.foo_bar">foo_bar</a></li></ul></section><section><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block method"><li><a href="#impl-Foo">Foo</a></li><li><a href="#impl-Baz">Baz</a></li><li><a href="#impl-Add">Add</a></li><li><a href="#impl-Subtract">Subtract</a></li></ul></section></div></nav><main><div class="width-limiter"><script src="../../search.js" type="text/javascript"></script><script>function onSearchFormSubmit(event){event.preventDefault();const searchQuery=document.getElementById("search-input").value;const url=new URL(window.location.href);if(searchQuery){url.searchParams.set('search',searchQuery)}else{url.searchParams.delete('search')}history.pushState({search:searchQuery},"",url);window.dispatchEvent(new HashChangeEvent("hashchange"))}document.addEventListener('DOMContentLoaded',()=>{const searchbar=document.getElementById("search-input");const searchForm=document.getElementById("search-form");searchbar.addEventListener("keyup",function(event){onSearchFormSubmit(event)});searchbar.addEventListener("search",function(event){onSearchFormSubmit(event)});function onQueryParamsChange(){const searchParams=new URLSearchParams(window.location.search);const query=searchParams.get("search");const searchSection=document.getElementById('search');const mainSection=document.getElementById('main-content');const searchInput=document.getElementById('search-input');if(query){searchInput.value=query;const results=Object.values(SEARCH_INDEX).flat().filter(item=>{const lowerQuery=query.toLowerCase();return item.name.toLowerCase().includes(lowerQuery)});const header=`<h1>Results for ${query}</h1>`;if(results.length>0){const resultList=results.map(item=>{const formattedName=`<span class="type ${item.type_name}">${item.name}</span>`;const name=[...item.module_info,formattedName].join("::");const path=["../..",...item.module_info,item.html_filename].join("/");const left=`<td><span>${name}</span></td>`;const right=`<td><p>${item.preview}</p></td>`;return`<tr onclick="window.location='${path}';">${left}${right}</tr>`}).join('');searchSection.innerHTML=`${header}<table>${resultList}</table>`}else{searchSection.innerHTML=`${header}<p>No results found.</p>`}searchSection.setAttribute("class","search-results");mainSection.setAttribute("class","content hidden")}else{searchSection.setAttribute("class","search-results hidden");mainSection.setAttribute("class","content")}}window.addEventListener('hashchange',onQueryParamsChange);onQueryParamsChange()})</script><nav class="sub"><form id="search-form" class="search-form" onsubmit="onSearchFormSubmit(event)"><div class="search-container"><input id="search-input" class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Search the docs..." type="search"></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1 class="fqn"><span class="in-band">Struct <a class="mod" href="../index.html">impl_traits</a><span>::</span><a class="mod" href="index.html">bar</a><span>::</span><a class="struct" href="#">Bar</a></span></h1></div><div class="docblock item-decl"><pre class="sway struct"><code>pub struct Bar {}</code></pre></div><h2 id="methods" class="small-section-header">Implementations<a href="#methods" class="anchor"></a></h2><div id="methods-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Bar" class="impl has-srclink"><a href="#impl-Bar" class="anchor"></a><h3 class="code-header in-band">impl Bar</h3></div></summary><div class="impl-items"><div id="method.foo_bar" class="method trait-impl"><a href="#method.foo_bar" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo_bar">foo_bar</a>()</h4></div></div></details></div><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Foo" class="impl has-srclink"><a href="#impl-Foo" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Foo.html">Foo</a> for Bar</h3></div></summary><div class="impl-items"><details class="swaydoc-toggle method-toggle" open><summary><div id="method.foo" class="method trait-impl"><a href="#method.foo" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo">foo</a>()</h4></div></summary><div class="docblock"><p>something more about foo();</p>
+    </div></details></div></details><div id="impl-Baz" class="impl has-srclink"><a href="#impl-Baz" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Baz.html">Baz</a> for Bar</h3></div><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Add" class="impl has-srclink"><a href="#impl-Add" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../../core/ops/trait.Add.html">Add</a> for Bar</h3></div></summary><div class="impl-items"><div id="method.add" class="method trait-impl"><a href="#method.add" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.add">add</a>(self, other: Self) -&gt; Self</h4></div></div></details><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Subtract" class="impl has-srclink"><a href="#impl-Subtract" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../../core/ops/trait.Subtract.html">Subtract</a> for Bar</h3></div></summary><div class="impl-items"><div id="method.subtract" class="method trait-impl"><a href="#method.subtract" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.subtract">subtract</a>(self, other: Self) -&gt; Self</h4></div></div></details></div></section><section id="search" class="search-results"></section></div></main><script src="../../static.files/highlight.js"></script><script>hljs.highlightAll();</script></body></html>"##]],
     );
     assert_search_js(
         &doc_path,
         &expect![[r#"
-            var SEARCH_INDEX={"core":[{"html_filename":"trait.AsRawSlice.html","module_info":["core","raw_slice"],"name":"AsRawSlice","preview":"Trait to return a type as a <code>raw_slice</code>.\n","type_name":"trait"},{"html_filename":"fn.from_str_array.html","module_info":["core","str"],"name":"from_str_array","preview":"","type_name":"function"},{"html_filename":"trait.Add.html","module_info":["core","ops"],"name":"Add","preview":"Trait for the addition of two values.\n","type_name":"trait"},{"html_filename":"trait.Subtract.html","module_info":["core","ops"],"name":"Subtract","preview":"Trait for the subtraction of two values.\n","type_name":"trait"},{"html_filename":"trait.Multiply.html","module_info":["core","ops"],"name":"Multiply","preview":"Trait for the multiplication of two values.\n","type_name":"trait"},{"html_filename":"trait.Divide.html","module_info":["core","ops"],"name":"Divide","preview":"Trait for the division of two values.\n","type_name":"trait"},{"html_filename":"trait.Mod.html","module_info":["core","ops"],"name":"Mod","preview":"Trait for the modulo of two values.\n","type_name":"trait"},{"html_filename":"trait.Not.html","module_info":["core","ops"],"name":"Not","preview":"Trait to invert a type.\n","type_name":"trait"},{"html_filename":"trait.Eq.html","module_info":["core","ops"],"name":"Eq","preview":"Trait to evaluate if two types are equal.\n","type_name":"trait"},{"html_filename":"trait.Ord.html","module_info":["core","ops"],"name":"Ord","preview":"Trait to evaluate if one value is greater or less than another of the same type.\n","type_name":"trait"},{"html_filename":"trait.BitwiseAnd.html","module_info":["core","ops"],"name":"BitwiseAnd","preview":"Trait to bitwise AND two values of the same type.\n","type_name":"trait"},{"html_filename":"trait.BitwiseOr.html","module_info":["core","ops"],"name":"BitwiseOr","preview":"Trait to bitwise OR two values of the same type.\n","type_name":"trait"},{"html_filename":"trait.BitwiseXor.html","module_info":["core","ops"],"name":"BitwiseXor","preview":"Trait to bitwise XOR two values of the same type.\n","type_name":"trait"},{"html_filename":"trait.Shift.html","module_info":["core","ops"],"name":"Shift","preview":"Trait to bit shift a value.\n","type_name":"trait"},{"html_filename":"fn.ok_str_eq.html","module_info":["core","ops"],"name":"ok_str_eq","preview":"","type_name":"function"},{"html_filename":"struct.StorageKey.html","module_info":["core","storage"],"name":"StorageKey","preview":"Describes a location in storage.\n","type_name":"struct"},{"html_filename":"struct.Buffer.html","module_info":["core","codec"],"name":"Buffer","preview":"","type_name":"struct"},{"html_filename":"struct.BufferReader.html","module_info":["core","codec"],"name":"BufferReader","preview":"","type_name":"struct"},{"html_filename":"trait.AbiDecode.html","module_info":["core","codec"],"name":"AbiDecode","preview":"","type_name":"trait"},{"html_filename":"trait.AbiEncode.html","module_info":["core","codec"],"name":"AbiEncode","preview":"","type_name":"trait"},{"html_filename":"fn.encode.html","module_info":["core","codec"],"name":"encode","preview":"","type_name":"function"},{"html_filename":"fn.abi_decode.html","module_info":["core","codec"],"name":"abi_decode","preview":"","type_name":"function"},{"html_filename":"fn.abi_decode_in_place.html","module_info":["core","codec"],"name":"abi_decode_in_place","preview":"","type_name":"function"},{"html_filename":"fn.contract_call.html","module_info":["core","codec"],"name":"contract_call","preview":"","type_name":"function"},{"html_filename":"fn.decode_script_data.html","module_info":["core","codec"],"name":"decode_script_data","preview":"","type_name":"function"},{"html_filename":"fn.decode_predicate_data.html","module_info":["core","codec"],"name":"decode_predicate_data","preview":"","type_name":"function"},{"html_filename":"fn.decode_predicate_data_by_index.html","module_info":["core","codec"],"name":"decode_predicate_data_by_index","preview":"","type_name":"function"},{"html_filename":"fn.decode_first_param.html","module_info":["core","codec"],"name":"decode_first_param","preview":"","type_name":"function"},{"html_filename":"fn.decode_second_param.html","module_info":["core","codec"],"name":"decode_second_param","preview":"","type_name":"function"},{"html_filename":"primitive.u256.html","module_info":["core"],"name":"u256","preview":"256-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u64.html","module_info":["core"],"name":"u64","preview":"64-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u32.html","module_info":["core"],"name":"u32","preview":"32-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u16.html","module_info":["core"],"name":"u16","preview":"16-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u8.html","module_info":["core"],"name":"u8","preview":"8-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.b256.html","module_info":["core"],"name":"b256","preview":"256 bits (32 bytes), i.e. a hash","type_name":"primitive"},{"html_filename":"primitive.str.html","module_info":["core"],"name":"str","preview":"string slice","type_name":"primitive"},{"html_filename":"primitive.bool.html","module_info":["core"],"name":"bool","preview":"Boolean true or false","type_name":"primitive"},{"html_filename":"primitive.str[0].html","module_info":["core"],"name":"str[0]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[1].html","module_info":["core"],"name":"str[1]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[2].html","module_info":["core"],"name":"str[2]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[3].html","module_info":["core"],"name":"str[3]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[4].html","module_info":["core"],"name":"str[4]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[5].html","module_info":["core"],"name":"str[5]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[6].html","module_info":["core"],"name":"str[6]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[7].html","module_info":["core"],"name":"str[7]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[8].html","module_info":["core"],"name":"str[8]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[9].html","module_info":["core"],"name":"str[9]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[10].html","module_info":["core"],"name":"str[10]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[11].html","module_info":["core"],"name":"str[11]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[12].html","module_info":["core"],"name":"str[12]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[13].html","module_info":["core"],"name":"str[13]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[14].html","module_info":["core"],"name":"str[14]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[15].html","module_info":["core"],"name":"str[15]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[16].html","module_info":["core"],"name":"str[16]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[17].html","module_info":["core"],"name":"str[17]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[18].html","module_info":["core"],"name":"str[18]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[19].html","module_info":["core"],"name":"str[19]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[20].html","module_info":["core"],"name":"str[20]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[21].html","module_info":["core"],"name":"str[21]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[22].html","module_info":["core"],"name":"str[22]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[23].html","module_info":["core"],"name":"str[23]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[24].html","module_info":["core"],"name":"str[24]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[25].html","module_info":["core"],"name":"str[25]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[26].html","module_info":["core"],"name":"str[26]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[27].html","module_info":["core"],"name":"str[27]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[28].html","module_info":["core"],"name":"str[28]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[29].html","module_info":["core"],"name":"str[29]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[30].html","module_info":["core"],"name":"str[30]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[31].html","module_info":["core"],"name":"str[31]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[32].html","module_info":["core"],"name":"str[32]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[33].html","module_info":["core"],"name":"str[33]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[34].html","module_info":["core"],"name":"str[34]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[35].html","module_info":["core"],"name":"str[35]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[36].html","module_info":["core"],"name":"str[36]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[37].html","module_info":["core"],"name":"str[37]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[38].html","module_info":["core"],"name":"str[38]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[39].html","module_info":["core"],"name":"str[39]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[40].html","module_info":["core"],"name":"str[40]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[41].html","module_info":["core"],"name":"str[41]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[42].html","module_info":["core"],"name":"str[42]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[43].html","module_info":["core"],"name":"str[43]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[44].html","module_info":["core"],"name":"str[44]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[45].html","module_info":["core"],"name":"str[45]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[46].html","module_info":["core"],"name":"str[46]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[47].html","module_info":["core"],"name":"str[47]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[48].html","module_info":["core"],"name":"str[48]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[49].html","module_info":["core"],"name":"str[49]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[50].html","module_info":["core"],"name":"str[50]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[51].html","module_info":["core"],"name":"str[51]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[52].html","module_info":["core"],"name":"str[52]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[53].html","module_info":["core"],"name":"str[53]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[54].html","module_info":["core"],"name":"str[54]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[55].html","module_info":["core"],"name":"str[55]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[56].html","module_info":["core"],"name":"str[56]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[57].html","module_info":["core"],"name":"str[57]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[58].html","module_info":["core"],"name":"str[58]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[59].html","module_info":["core"],"name":"str[59]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[60].html","module_info":["core"],"name":"str[60]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[61].html","module_info":["core"],"name":"str[61]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[62].html","module_info":["core"],"name":"str[62]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[63].html","module_info":["core"],"name":"str[63]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[64].html","module_info":["core"],"name":"str[64]","preview":"fixed-length string","type_name":"primitive"}],"impl_traits":[{"html_filename":"trait.Foo.html","module_info":["impl_traits","foo"],"name":"Foo","preview":"","type_name":"trait"},{"html_filename":"trait.Baz.html","module_info":["impl_traits","foo"],"name":"Baz","preview":"","type_name":"trait"},{"html_filename":"struct.Bar.html","module_info":["impl_traits","bar"],"name":"Bar","preview":"","type_name":"struct"}]};
+            var SEARCH_INDEX={"core":[{"html_filename":"trait.AsRawSlice.html","module_info":["core","raw_slice"],"name":"AsRawSlice","preview":"Trait to return a type as a <code>raw_slice</code>.\n","type_name":"trait"},{"html_filename":"fn.from_str_array.html","module_info":["core","str"],"name":"from_str_array","preview":"","type_name":"function"},{"html_filename":"trait.Add.html","module_info":["core","ops"],"name":"Add","preview":"Trait for the addition of two values.\n","type_name":"trait"},{"html_filename":"trait.Subtract.html","module_info":["core","ops"],"name":"Subtract","preview":"Trait for the subtraction of two values.\n","type_name":"trait"},{"html_filename":"trait.Multiply.html","module_info":["core","ops"],"name":"Multiply","preview":"Trait for the multiplication of two values.\n","type_name":"trait"},{"html_filename":"trait.Divide.html","module_info":["core","ops"],"name":"Divide","preview":"Trait for the division of two values.\n","type_name":"trait"},{"html_filename":"trait.Mod.html","module_info":["core","ops"],"name":"Mod","preview":"Trait for the modulo of two values.\n","type_name":"trait"},{"html_filename":"trait.Not.html","module_info":["core","ops"],"name":"Not","preview":"Trait to invert a type.\n","type_name":"trait"},{"html_filename":"trait.Eq.html","module_info":["core","ops"],"name":"Eq","preview":"Trait to evaluate if two types are equal.\n","type_name":"trait"},{"html_filename":"trait.Ord.html","module_info":["core","ops"],"name":"Ord","preview":"Trait to evaluate if one value is greater or less than another of the same type.\n","type_name":"trait"},{"html_filename":"trait.BitwiseAnd.html","module_info":["core","ops"],"name":"BitwiseAnd","preview":"Trait to bitwise AND two values of the same type.\n","type_name":"trait"},{"html_filename":"trait.BitwiseOr.html","module_info":["core","ops"],"name":"BitwiseOr","preview":"Trait to bitwise OR two values of the same type.\n","type_name":"trait"},{"html_filename":"trait.BitwiseXor.html","module_info":["core","ops"],"name":"BitwiseXor","preview":"Trait to bitwise XOR two values of the same type.\n","type_name":"trait"},{"html_filename":"trait.Shift.html","module_info":["core","ops"],"name":"Shift","preview":"Trait to bit shift a value.\n","type_name":"trait"},{"html_filename":"trait.TotalOrd.html","module_info":["core","ops"],"name":"TotalOrd","preview":"Trait to compare values of the same type.\n","type_name":"trait"},{"html_filename":"fn.ok_str_eq.html","module_info":["core","ops"],"name":"ok_str_eq","preview":"","type_name":"function"},{"html_filename":"struct.StorageKey.html","module_info":["core","storage"],"name":"StorageKey","preview":"Describes a location in storage.\n","type_name":"struct"},{"html_filename":"struct.Buffer.html","module_info":["core","codec"],"name":"Buffer","preview":"","type_name":"struct"},{"html_filename":"struct.BufferReader.html","module_info":["core","codec"],"name":"BufferReader","preview":"","type_name":"struct"},{"html_filename":"trait.AbiDecode.html","module_info":["core","codec"],"name":"AbiDecode","preview":"","type_name":"trait"},{"html_filename":"trait.AbiEncode.html","module_info":["core","codec"],"name":"AbiEncode","preview":"","type_name":"trait"},{"html_filename":"fn.encode.html","module_info":["core","codec"],"name":"encode","preview":"","type_name":"function"},{"html_filename":"fn.abi_decode.html","module_info":["core","codec"],"name":"abi_decode","preview":"","type_name":"function"},{"html_filename":"fn.abi_decode_in_place.html","module_info":["core","codec"],"name":"abi_decode_in_place","preview":"","type_name":"function"},{"html_filename":"fn.contract_call.html","module_info":["core","codec"],"name":"contract_call","preview":"","type_name":"function"},{"html_filename":"fn.decode_script_data.html","module_info":["core","codec"],"name":"decode_script_data","preview":"","type_name":"function"},{"html_filename":"fn.decode_predicate_data.html","module_info":["core","codec"],"name":"decode_predicate_data","preview":"","type_name":"function"},{"html_filename":"fn.decode_predicate_data_by_index.html","module_info":["core","codec"],"name":"decode_predicate_data_by_index","preview":"","type_name":"function"},{"html_filename":"fn.decode_first_param.html","module_info":["core","codec"],"name":"decode_first_param","preview":"","type_name":"function"},{"html_filename":"fn.decode_second_param.html","module_info":["core","codec"],"name":"decode_second_param","preview":"","type_name":"function"},{"html_filename":"primitive.u256.html","module_info":["core"],"name":"u256","preview":"256-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u64.html","module_info":["core"],"name":"u64","preview":"64-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u32.html","module_info":["core"],"name":"u32","preview":"32-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u16.html","module_info":["core"],"name":"u16","preview":"16-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.u8.html","module_info":["core"],"name":"u8","preview":"8-bit unsigned integer","type_name":"primitive"},{"html_filename":"primitive.b256.html","module_info":["core"],"name":"b256","preview":"256 bits (32 bytes), i.e. a hash","type_name":"primitive"},{"html_filename":"primitive.str.html","module_info":["core"],"name":"str","preview":"string slice","type_name":"primitive"},{"html_filename":"primitive.bool.html","module_info":["core"],"name":"bool","preview":"Boolean true or false","type_name":"primitive"},{"html_filename":"primitive.str[0].html","module_info":["core"],"name":"str[0]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[1].html","module_info":["core"],"name":"str[1]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[2].html","module_info":["core"],"name":"str[2]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[3].html","module_info":["core"],"name":"str[3]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[4].html","module_info":["core"],"name":"str[4]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[5].html","module_info":["core"],"name":"str[5]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[6].html","module_info":["core"],"name":"str[6]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[7].html","module_info":["core"],"name":"str[7]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[8].html","module_info":["core"],"name":"str[8]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[9].html","module_info":["core"],"name":"str[9]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[10].html","module_info":["core"],"name":"str[10]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[11].html","module_info":["core"],"name":"str[11]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[12].html","module_info":["core"],"name":"str[12]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[13].html","module_info":["core"],"name":"str[13]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[14].html","module_info":["core"],"name":"str[14]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[15].html","module_info":["core"],"name":"str[15]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[16].html","module_info":["core"],"name":"str[16]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[17].html","module_info":["core"],"name":"str[17]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[18].html","module_info":["core"],"name":"str[18]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[19].html","module_info":["core"],"name":"str[19]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[20].html","module_info":["core"],"name":"str[20]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[21].html","module_info":["core"],"name":"str[21]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[22].html","module_info":["core"],"name":"str[22]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[23].html","module_info":["core"],"name":"str[23]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[24].html","module_info":["core"],"name":"str[24]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[25].html","module_info":["core"],"name":"str[25]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[26].html","module_info":["core"],"name":"str[26]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[27].html","module_info":["core"],"name":"str[27]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[28].html","module_info":["core"],"name":"str[28]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[29].html","module_info":["core"],"name":"str[29]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[30].html","module_info":["core"],"name":"str[30]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[31].html","module_info":["core"],"name":"str[31]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[32].html","module_info":["core"],"name":"str[32]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[33].html","module_info":["core"],"name":"str[33]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[34].html","module_info":["core"],"name":"str[34]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[35].html","module_info":["core"],"name":"str[35]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[36].html","module_info":["core"],"name":"str[36]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[37].html","module_info":["core"],"name":"str[37]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[38].html","module_info":["core"],"name":"str[38]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[39].html","module_info":["core"],"name":"str[39]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[40].html","module_info":["core"],"name":"str[40]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[41].html","module_info":["core"],"name":"str[41]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[42].html","module_info":["core"],"name":"str[42]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[43].html","module_info":["core"],"name":"str[43]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[44].html","module_info":["core"],"name":"str[44]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[45].html","module_info":["core"],"name":"str[45]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[46].html","module_info":["core"],"name":"str[46]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[47].html","module_info":["core"],"name":"str[47]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[48].html","module_info":["core"],"name":"str[48]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[49].html","module_info":["core"],"name":"str[49]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[50].html","module_info":["core"],"name":"str[50]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[51].html","module_info":["core"],"name":"str[51]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[52].html","module_info":["core"],"name":"str[52]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[53].html","module_info":["core"],"name":"str[53]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[54].html","module_info":["core"],"name":"str[54]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[55].html","module_info":["core"],"name":"str[55]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[56].html","module_info":["core"],"name":"str[56]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[57].html","module_info":["core"],"name":"str[57]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[58].html","module_info":["core"],"name":"str[58]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[59].html","module_info":["core"],"name":"str[59]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[60].html","module_info":["core"],"name":"str[60]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[61].html","module_info":["core"],"name":"str[61]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[62].html","module_info":["core"],"name":"str[62]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[63].html","module_info":["core"],"name":"str[63]","preview":"fixed-length string","type_name":"primitive"},{"html_filename":"primitive.str[64].html","module_info":["core"],"name":"str[64]","preview":"fixed-length string","type_name":"primitive"}],"impl_traits":[{"html_filename":"trait.Foo.html","module_info":["impl_traits","foo"],"name":"Foo","preview":"","type_name":"trait"},{"html_filename":"trait.Baz.html","module_info":["impl_traits","foo"],"name":"Baz","preview":"","type_name":"trait"},{"html_filename":"struct.Bar.html","module_info":["impl_traits","bar"],"name":"Bar","preview":"","type_name":"struct"}]};
             "object"==typeof exports&&"undefined"!=typeof module&&(module.exports=SEARCH_INDEX);"#]],
     );
     assert_file_tree(
@@ -155,6 +154,7 @@ fn test_impl_traits_default() {
             "core/ops/trait.Ord.html",
             "core/ops/trait.Shift.html",
             "core/ops/trait.Subtract.html",
+            "core/ops/trait.TotalOrd.html",
             "core/raw_slice/index.html",
             "core/raw_slice/trait.AsRawSlice.html",
             "core/storage/index.html",
@@ -195,7 +195,7 @@ fn test_impl_traits_no_deps() {
         &doc_path,
         project_name,
         &expect![[
-            r##"<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="swaydoc"><meta name="description" content="API documentation for the Sway `Bar` struct in `bar`."><meta name="keywords" content="sway, swaylang, sway-lang, Bar"><link rel="icon" href="../../static.files/sway-logo.svg"><title>Bar in bar - Sway</title><link rel="stylesheet" type="text/css" href="../../static.files/normalize.css"><link rel="stylesheet" type="text/css" href="../../static.files/swaydoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../static.files/ayu.css"><link rel="stylesheet" href="../../static.files/ayu.min.css"></head><body class="swaydoc struct"><nav class="sidebar"><a class="sidebar-logo" href="../../impl_traits_clone/index.html"><div class="logo-container"><img class="sway-logo" src="../../static.files/sway-logo.svg" alt="logo"></div></a><h2 class="location">Struct Bar</h2><div class="sidebar-elems"><section><h3><a href="#methods">Methods</a></h3><ul class="block method"><li><a href="#method.foo_bar">foo_bar</a></li></ul></section><section><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block method"><li><a href="#impl-Foo">Foo</a></li><li><a href="#impl-Baz">Baz</a></li><li><a href="#impl-Add">Add</a></li><li><a href="#impl-Subtract">Subtract</a></li></ul></section></div></nav><main><div class="width-limiter"><script src="../../search.js" type="text/javascript"></script><script>function onSearchFormSubmit(event){event.preventDefault();const searchQuery=document.getElementById("search-input").value;const url=new URL(window.location.href);if(searchQuery){url.searchParams.set('search',searchQuery)}else{url.searchParams.delete('search')}history.pushState({search:searchQuery},"",url);window.dispatchEvent(new HashChangeEvent("hashchange"))}document.addEventListener('DOMContentLoaded',()=>{const searchbar=document.getElementById("search-input");const searchForm=document.getElementById("search-form");searchbar.addEventListener("keyup",function(event){searchForm.dispatchEvent(new Event('submit'))});searchbar.addEventListener("search",function(event){searchForm.dispatchEvent(new Event('submit'))});function onQueryParamsChange(){const searchParams=new URLSearchParams(window.location.search);const query=searchParams.get("search");const searchSection=document.getElementById('search');const mainSection=document.getElementById('main-content');const searchInput=document.getElementById('search-input');if(query){searchInput.value=query;const results=Object.values(SEARCH_INDEX).flat().filter(item=>{const lowerQuery=query.toLowerCase();return item.name.toLowerCase().includes(lowerQuery)});const header=`<h1>Results for ${query}</h1>`;if(results.length>0){const resultList=results.map(item=>{const formattedName=`<span class="type ${item.type_name}">${item.name}</span>`;const name=[...item.module_info,formattedName].join("::");const path=["../..",...item.module_info,item.html_filename].join("/");const left=`<td><span>${name}</span></td>`;const right=`<td><p>${item.preview}</p></td>`;return`<tr onclick="window.location='${path}';">${left}${right}</tr>`}).join('');searchSection.innerHTML=`${header}<table>${resultList}</table>`}else{searchSection.innerHTML=`${header}<p>No results found.</p>`}searchSection.setAttribute("class","search-results");mainSection.setAttribute("class","content hidden")}else{searchSection.setAttribute("class","search-results hidden");mainSection.setAttribute("class","content")}}window.addEventListener('hashchange',onQueryParamsChange);onQueryParamsChange()})</script><nav class="sub"><form id="search-form" class="search-form" onsubmit="onSearchFormSubmit(event)"><div class="search-container"><input id="search-input" class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Search the docs..." type="search"></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1 class="fqn"><span class="in-band">Struct <a class="mod" href="../index.html">impl_traits_clone</a><span>::</span><a class="mod" href="index.html">bar</a><span>::</span><a class="struct" href="#">Bar</a></span></h1></div><div class="docblock item-decl"><pre class="sway struct"><code>pub struct Bar {}</code></pre></div><h2 id="methods" class="small-section-header">Implementations<a href="#methods" class="anchor"></a></h2><div id="methods-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Bar" class="impl has-srclink"><a href="#impl-Bar" class="anchor"></a><h3 class="code-header in-band">impl Bar</h3></div></summary><div class="impl-items"><div id="method.foo_bar" class="method trait-impl"><a href="#method.foo_bar" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo_bar">foo_bar</a>()</h4></div></div></details></div><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Foo" class="impl has-srclink"><a href="#impl-Foo" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Foo.html">Foo</a> for Bar</h3></div></summary><div class="impl-items"><details class="swaydoc-toggle method-toggle" open><summary><div id="method.foo" class="method trait-impl"><a href="#method.foo" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo">foo</a>()</h4></div></summary><div class="docblock"><p>something more about foo();</p>
+            r##"<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="swaydoc"><meta name="description" content="API documentation for the Sway `Bar` struct in `bar`."><meta name="keywords" content="sway, swaylang, sway-lang, Bar"><link rel="icon" href="../../static.files/sway-logo.svg"><title>Bar in bar - Sway</title><link rel="stylesheet" type="text/css" href="../../static.files/normalize.css"><link rel="stylesheet" type="text/css" href="../../static.files/swaydoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../static.files/ayu.css"><link rel="stylesheet" href="../../static.files/ayu.min.css"></head><body class="swaydoc struct"><nav class="sidebar"><a class="sidebar-logo" href="../../impl_traits_clone/index.html"><div class="logo-container"><img class="sway-logo" src="../../static.files/sway-logo.svg" alt="logo"></div></a><h2 class="location">Struct Bar</h2><div class="sidebar-elems"><section><h3><a href="#methods">Methods</a></h3><ul class="block method"><li><a href="#method.foo_bar">foo_bar</a></li></ul></section><section><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block method"><li><a href="#impl-Foo">Foo</a></li><li><a href="#impl-Baz">Baz</a></li><li><a href="#impl-Add">Add</a></li><li><a href="#impl-Subtract">Subtract</a></li></ul></section></div></nav><main><div class="width-limiter"><script src="../../search.js" type="text/javascript"></script><script>function onSearchFormSubmit(event){event.preventDefault();const searchQuery=document.getElementById("search-input").value;const url=new URL(window.location.href);if(searchQuery){url.searchParams.set('search',searchQuery)}else{url.searchParams.delete('search')}history.pushState({search:searchQuery},"",url);window.dispatchEvent(new HashChangeEvent("hashchange"))}document.addEventListener('DOMContentLoaded',()=>{const searchbar=document.getElementById("search-input");const searchForm=document.getElementById("search-form");searchbar.addEventListener("keyup",function(event){onSearchFormSubmit(event)});searchbar.addEventListener("search",function(event){onSearchFormSubmit(event)});function onQueryParamsChange(){const searchParams=new URLSearchParams(window.location.search);const query=searchParams.get("search");const searchSection=document.getElementById('search');const mainSection=document.getElementById('main-content');const searchInput=document.getElementById('search-input');if(query){searchInput.value=query;const results=Object.values(SEARCH_INDEX).flat().filter(item=>{const lowerQuery=query.toLowerCase();return item.name.toLowerCase().includes(lowerQuery)});const header=`<h1>Results for ${query}</h1>`;if(results.length>0){const resultList=results.map(item=>{const formattedName=`<span class="type ${item.type_name}">${item.name}</span>`;const name=[...item.module_info,formattedName].join("::");const path=["../..",...item.module_info,item.html_filename].join("/");const left=`<td><span>${name}</span></td>`;const right=`<td><p>${item.preview}</p></td>`;return`<tr onclick="window.location='${path}';">${left}${right}</tr>`}).join('');searchSection.innerHTML=`${header}<table>${resultList}</table>`}else{searchSection.innerHTML=`${header}<p>No results found.</p>`}searchSection.setAttribute("class","search-results");mainSection.setAttribute("class","content hidden")}else{searchSection.setAttribute("class","search-results hidden");mainSection.setAttribute("class","content")}}window.addEventListener('hashchange',onQueryParamsChange);onQueryParamsChange()})</script><nav class="sub"><form id="search-form" class="search-form" onsubmit="onSearchFormSubmit(event)"><div class="search-container"><input id="search-input" class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Search the docs..." type="search"></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1 class="fqn"><span class="in-band">Struct <a class="mod" href="../index.html">impl_traits_clone</a><span>::</span><a class="mod" href="index.html">bar</a><span>::</span><a class="struct" href="#">Bar</a></span></h1></div><div class="docblock item-decl"><pre class="sway struct"><code>pub struct Bar {}</code></pre></div><h2 id="methods" class="small-section-header">Implementations<a href="#methods" class="anchor"></a></h2><div id="methods-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Bar" class="impl has-srclink"><a href="#impl-Bar" class="anchor"></a><h3 class="code-header in-band">impl Bar</h3></div></summary><div class="impl-items"><div id="method.foo_bar" class="method trait-impl"><a href="#method.foo_bar" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo_bar">foo_bar</a>()</h4></div></div></details></div><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Foo" class="impl has-srclink"><a href="#impl-Foo" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Foo.html">Foo</a> for Bar</h3></div></summary><div class="impl-items"><details class="swaydoc-toggle method-toggle" open><summary><div id="method.foo" class="method trait-impl"><a href="#method.foo" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.foo">foo</a>()</h4></div></summary><div class="docblock"><p>something more about foo();</p>
 </div></details></div></details><div id="impl-Baz" class="impl has-srclink"><a href="#impl-Baz" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../foo/trait.Baz.html">Baz</a> for Bar</h3></div><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Add" class="impl has-srclink"><a href="#impl-Add" class="anchor"></a><h3 class="code-header in-band">impl Add for Bar</h3></div></summary><div class="impl-items"><div id="method.add" class="method trait-impl"><a href="#method.add" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.add">add</a>(self, other: Self) -&gt; Self</h4></div></div></details><details class="swaydoc-toggle implementors-toggle" open><summary><div id="impl-Subtract" class="impl has-srclink"><a href="#impl-Subtract" class="anchor"></a><h3 class="code-header in-band">impl Subtract for Bar</h3></div></summary><div class="impl-items"><div id="method.subtract" class="method trait-impl"><a href="#method.subtract" class="anchor"></a><h4 class="code-header">fn <a class="fnname" href="#method.subtract">subtract</a>(self, other: Self) -&gt; Self</h4></div></div></details></div></section><section id="search" class="search-results"></section></div></main><script src="../../static.files/highlight.js"></script><script>hljs.highlightAll();</script></body></html>"##
         ]],
     );
diff --git a/forc-plugins/forc-fmt/Cargo.toml b/forc-plugins/forc-fmt/Cargo.toml
index fd0ae98f45e..d1fdedcce41 100644
--- a/forc-plugins/forc-fmt/Cargo.toml
+++ b/forc-plugins/forc-fmt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-fmt"
-version = "0.60.0"
+version.workspace = true
 description = "A `forc` plugin for running the Sway code formatter."
 authors.workspace = true
 edition.workspace = true
@@ -9,14 +9,14 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1"
-clap = { version = "4.5.4", features = ["derive"] }
-forc-pkg = { version = "0.60.0", path = "../../forc-pkg" }
-forc-tracing = { version = "0.60.0", path = "../../forc-tracing" }
-forc-util = { version = "0.60.0", path = "../../forc-util" }
-prettydiff = "0.5"
-sway-core = { version = "0.60.0", path = "../../sway-core" }
-sway-utils = { version = "0.60.0", path = "../../sway-utils" }
-swayfmt = { version = "0.60.0", path = "../../swayfmt" }
-taplo = "0.7"
-tracing = "0.1"
+anyhow.workspace = true
+clap = { workspace = true, features = ["derive"] }
+forc-pkg.workspace = true
+forc-tracing.workspace = true
+forc-util.workspace = true
+prettydiff.workspace = true
+sway-core.workspace = true
+sway-utils.workspace = true
+swayfmt.workspace = true
+taplo.workspace = true
+tracing.workspace = true
diff --git a/forc-plugins/forc-lsp/Cargo.toml b/forc-plugins/forc-lsp/Cargo.toml
index f49074fe946..83ed86b61ad 100644
--- a/forc-plugins/forc-lsp/Cargo.toml
+++ b/forc-plugins/forc-lsp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-lsp"
-version = "0.60.0"
+version.workspace = true
 description = "A simple `forc` plugin for starting the sway language server."
 authors.workspace = true
 edition.workspace = true
@@ -9,8 +9,8 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1"
-clap = { version = "4.5.4", features = ["derive"] }
-sway-lsp = { version = "0.60.0", path = "../../sway-lsp" }
-tikv-jemallocator = "0.5"
-tokio = { version = "1.8" }
+anyhow.workspace = true
+clap = { workspace = true, features = ["derive"] }
+sway-lsp.workspace = true
+tikv-jemallocator.workspace = true
+tokio.workspace = true
diff --git a/forc-plugins/forc-lsp/src/main.rs b/forc-plugins/forc-lsp/src/main.rs
index 2303f7785b2..b859e136135 100644
--- a/forc-plugins/forc-lsp/src/main.rs
+++ b/forc-plugins/forc-lsp/src/main.rs
@@ -1,7 +1,7 @@
 //! A simple `forc` plugin for starting the sway language server.
 //!
 //! Once installed and available via `PATH`, can be executed via `forc lsp`.
-
+#![recursion_limit = "256"]
 // Use Jemalloc for main binary
 #[global_allocator]
 static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
diff --git a/forc-plugins/forc-tx/Cargo.toml b/forc-plugins/forc-tx/Cargo.toml
index 0130164aff0..91fee672cf3 100644
--- a/forc-plugins/forc-tx/Cargo.toml
+++ b/forc-plugins/forc-tx/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-tx"
-version = "0.60.0"
+version.workspace = true
 description = "A `forc` plugin for constructing transactions."
 authors.workspace = true
 edition.workspace = true
@@ -16,12 +16,12 @@ name = "forc-tx"
 path = "src/main.rs"
 
 [dependencies]
-anyhow = "1"
-clap = { version = "4.5.4", features = ["derive", "env"] }
-devault = "0.1"
-forc-util = { version = "0.60.0", path = "../../forc-util" }
-fuel-tx = { workspace = true, features = ["serde", "test-helpers", "random"] }
+anyhow.workspace = true
+clap = { workspace = true, features = ["derive", "env"] }
+devault.workspace = true
+forc-util.workspace = true
+fuel-tx = { workspace = true, features = ["random", "test-helpers"] }
 fuel-types = { workspace = true, features = ["serde"] }
-serde = "1.0"
-serde_json = { version = "1" }
-thiserror = "1"
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
diff --git a/forc-test/Cargo.toml b/forc-test/Cargo.toml
index 70f7476dec9..3034b60dfbf 100644
--- a/forc-test/Cargo.toml
+++ b/forc-test/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-test"
-version = "0.60.0"
+version.workspace = true
 description = "A library for building and running Sway unit tests within Forc packages."
 authors.workspace = true
 edition.workspace = true
@@ -9,13 +9,13 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1"
-forc-pkg = { version = "0.60.0", path = "../forc-pkg" }
-fuel-abi-types = { workspace = true }
+anyhow.workspace = true
+forc-pkg.workspace = true
+fuel-abi-types.workspace = true
 fuel-tx = { workspace = true, features = ["test-helpers"] }
 fuel-vm = { workspace = true, features = ["random", "test-helpers"] }
-fuels-core = { workspace = true }
-rand = "0.8"
-rayon = "1.7.0"
-sway-core = { version = "0.60.0", path = "../sway-core" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
+fuels-core.workspace = true
+rand.workspace = true
+rayon.workspace = true
+sway-core.workspace = true
+sway-types.workspace = true
diff --git a/forc-test/src/execute.rs b/forc-test/src/execute.rs
index a2c6fe5eda5..3436261af94 100644
--- a/forc-test/src/execute.rs
+++ b/forc-test/src/execute.rs
@@ -16,14 +16,14 @@ use rand::{Rng, SeedableRng};
 
 use tx::Receipt;
 
-use vm::interpreter::InterpreterParams;
+use vm::interpreter::{InterpreterParams, MemoryInstance};
 use vm::state::DebugEval;
 use vm::state::ProgramState;
 
 /// An interface for executing a test within a VM [Interpreter] instance.
 #[derive(Debug, Clone)]
 pub struct TestExecutor {
-    pub interpreter: Interpreter<MemoryStorage, tx::Script, NotSupportedEcal>,
+    pub interpreter: Interpreter<MemoryInstance, MemoryStorage, tx::Script, NotSupportedEcal>,
     pub tx: vm::checked_transaction::Ready<tx::Script>,
     pub test_entry: PkgTestEntry,
     pub name: String,
@@ -118,9 +118,11 @@ impl TestExecutor {
             .map_err(|e| anyhow::anyhow!("{e:?}"))?;
 
         let interpreter_params = InterpreterParams::new(gas_price, &consensus_params);
+        let memory_instance = MemoryInstance::new();
+        let interpreter = Interpreter::with_storage(memory_instance, storage, interpreter_params);
 
         Ok(TestExecutor {
-            interpreter: Interpreter::with_storage(storage, interpreter_params),
+            interpreter,
             tx,
             test_entry: test_entry.clone(),
             name,
diff --git a/forc-test/src/lib.rs b/forc-test/src/lib.rs
index 70a255e47b6..58394055d75 100644
--- a/forc-test/src/lib.rs
+++ b/forc-test/src/lib.rs
@@ -5,7 +5,7 @@ use crate::execute::TestExecutor;
 use crate::setup::{
     ContractDeploymentSetup, ContractTestSetup, DeploymentSetup, ScriptTestSetup, TestSetup,
 };
-use forc_pkg as pkg;
+use forc_pkg::{self as pkg, BuildOpts};
 use fuel_abi_types::error_codes::ErrorSignal;
 use fuel_tx as tx;
 use fuel_vm::checked_transaction::builder::TransactionBuilderExt;
@@ -23,7 +23,7 @@ use sway_core::BuildTarget;
 use sway_types::Span;
 use tx::consensus_parameters::ConsensusParametersV1;
 use tx::{ConsensusParameters, ContractParameters, ScriptParameters, TxParameters};
-use vm::interpreter::InterpreterParams;
+use vm::interpreter::{InterpreterParams, MemoryInstance};
 use vm::prelude::SecretKey;
 
 /// The result of a `forc test` invocation.
@@ -209,8 +209,12 @@ impl PackageWithDeploymentToTest {
         let params = maxed_consensus_params();
         let storage = vm::storage::MemoryStorage::default();
         let interpreter_params = InterpreterParams::new(gas_price, params.clone());
-        let mut interpreter: vm::prelude::Interpreter<_, _, vm::interpreter::NotSupportedEcal> =
-            vm::interpreter::Interpreter::with_storage(storage, interpreter_params);
+        let mut interpreter: vm::prelude::Interpreter<_, _, _, vm::interpreter::NotSupportedEcal> =
+            vm::interpreter::Interpreter::with_storage(
+                MemoryInstance::new(),
+                storage,
+                interpreter_params,
+            );
 
         // Iterate and create deployment transactions for contract dependencies of the root
         // contract.
@@ -597,8 +601,8 @@ impl BuiltTests {
 
 /// First builds the package or workspace, ready for execution.
 pub fn build(opts: TestOpts) -> anyhow::Result<BuiltTests> {
-    let build_opts = opts.into();
-    let build_plan = pkg::BuildPlan::from_build_opts(&build_opts)?;
+    let build_opts: BuildOpts = opts.into();
+    let build_plan = pkg::BuildPlan::from_pkg_opts(&build_opts.pkg)?;
     let built = pkg::build_with_options(&build_opts)?;
     BuiltTests::from_built(built, &build_plan)
 }
@@ -668,7 +672,9 @@ pub fn decode_log_data(
     program_abi: &ProgramABI,
 ) -> anyhow::Result<DecodedLog> {
     let program_abi = match program_abi {
-        ProgramABI::Fuel(fuel_abi) => Some(fuel_abi),
+        ProgramABI::Fuel(fuel_abi) => Some(
+            fuel_abi_types::abi::unified_program::UnifiedProgramABI::from_counterpart(fuel_abi)?,
+        ),
         _ => None,
     }
     .ok_or_else(|| anyhow::anyhow!("only fuelvm is supported for log decoding"))?;
diff --git a/forc-tracing/Cargo.toml b/forc-tracing/Cargo.toml
index 24fec50a2d2..85240eec345 100644
--- a/forc-tracing/Cargo.toml
+++ b/forc-tracing/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-tracing"
-version = "0.60.0"
+version.workspace = true
 description = "Tracing utility shared between forc crates."
 authors.workspace = true
 edition.workspace = true
@@ -9,6 +9,9 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-ansi_term = "0.12"
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["ansi", "env-filter", "json"] }
+ansi_term.workspace = true
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["ansi", "env-filter", "json"] }
+
+[dev-dependencies]
+tracing-test = "0.2"
\ No newline at end of file
diff --git a/forc-tracing/src/lib.rs b/forc-tracing/src/lib.rs
index 7411091da19..656cb14ca14 100644
--- a/forc-tracing/src/lib.rs
+++ b/forc-tracing/src/lib.rs
@@ -4,11 +4,43 @@ use ansi_term::Colour;
 use std::str;
 use std::{env, io};
 use tracing::{Level, Metadata};
-use tracing_subscriber::{
+pub use tracing_subscriber::{
+    self,
     filter::{EnvFilter, LevelFilter},
-    fmt::MakeWriter,
+    fmt::{format::FmtSpan, MakeWriter},
 };
 
+const ACTION_COLUMN_WIDTH: usize = 12;
+
+/// Returns the indentation for the action prefix relative to [ACTION_COLUMN_WIDTH].
+fn get_action_indentation(action: &str) -> String {
+    if action.len() < ACTION_COLUMN_WIDTH {
+        " ".repeat(ACTION_COLUMN_WIDTH - action.len())
+    } else {
+        "".to_string()
+    }
+}
+
+/// Prints an action message with a green-bold prefix like "   Compiling ".
+pub fn println_action_green(action: &str, txt: &str) {
+    tracing::info!(
+        "{}{} {}",
+        get_action_indentation(action),
+        Colour::Green.bold().paint(action),
+        txt
+    );
+}
+
+/// Prints an action message with a red-bold prefix like "   Removing ".
+pub fn println_action_red(action: &str, txt: &str) {
+    tracing::info!(
+        "{}{} {}",
+        get_action_indentation(action),
+        Colour::Red.bold().paint(action),
+        txt
+    );
+}
+
 /// Prints a warning message to stdout with the yellow prefix "warning: ".
 pub fn println_warning(txt: &str) {
     tracing::warn!("{}: {}", Colour::Yellow.paint("warning"), txt);
@@ -52,8 +84,8 @@ const LOG_FILTER: &str = "RUST_LOG";
 
 // This allows us to write ERROR and WARN level logs to stderr and everything else to stdout.
 // https://docs.rs/tracing-subscriber/latest/tracing_subscriber/fmt/trait.MakeWriter.html
-struct StdioTracingWriter {
-    writer_mode: TracingWriterMode,
+pub struct StdioTracingWriter {
+    pub writer_mode: TracingWriterMode,
 }
 
 impl<'a> MakeWriter<'a> for StdioTracingWriter {
@@ -111,7 +143,6 @@ pub fn init_tracing_subscriber(options: TracingSubscriberOptions) {
         Some(_) => EnvFilter::try_from_default_env().expect("Invalid `RUST_LOG` provided"),
         None => EnvFilter::new("info"),
     };
-
     let level_filter = options
         .log_level
         .or_else(|| {
@@ -148,3 +179,39 @@ pub fn init_tracing_subscriber(options: TracingSubscriberOptions) {
         builder.init();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tracing_test::traced_test;
+
+    #[traced_test]
+    #[test]
+    fn test_println_action_green() {
+        let txt = "main.sw";
+        println_action_green("Compiling", txt);
+
+        let expected_action = "\x1b[1;32mCompiling\x1b[0m";
+        assert!(logs_contain(&format!("    {} {}", expected_action, txt)));
+    }
+
+    #[traced_test]
+    #[test]
+    fn test_println_action_green_long() {
+        let txt = "main.sw";
+        println_action_green("Supercalifragilistic", txt);
+
+        let expected_action = "\x1b[1;32mSupercalifragilistic\x1b[0m";
+        assert!(logs_contain(&format!("{} {}", expected_action, txt)));
+    }
+
+    #[traced_test]
+    #[test]
+    fn test_println_action_red() {
+        let txt = "main";
+        println_action_red("Removing", txt);
+
+        let expected_action = "\x1b[1;31mRemoving\x1b[0m";
+        assert!(logs_contain(&format!("     {} {}", expected_action, txt)));
+    }
+}
diff --git a/forc-util/Cargo.toml b/forc-util/Cargo.toml
index 3baf7848b75..f224c3028cb 100644
--- a/forc-util/Cargo.toml
+++ b/forc-util/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc-util"
-version = "0.60.0"
+version.workspace = true
 description = "Utility items shared between forc crates."
 authors.workspace = true
 edition.workspace = true
@@ -9,31 +9,31 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-annotate-snippets = { version = "0.10.1" }
-ansi_term = "0.12"
-anyhow = "1"
-clap = { version = "4.5.4", features = ["cargo", "derive", "env"] }
-dirs = "3.0.2"
-fd-lock = "4.0"
-forc-tracing = { version = "0.60.0", path = "../forc-tracing" }
-fuel-tx = { workspace = true, features = ["serde"], optional = true }
-hex = "0.4.3"
-paste = "1.0.14"
-regex = "1.10.2"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.73"
-serial_test = "3.0.0"
-sway-core = { version = "0.60.0", path = "../sway-core" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = [
+annotate-snippets.workspace = true
+ansi_term.workspace = true
+anyhow.workspace = true
+clap = { workspace = true, features = ["cargo", "derive", "env"] }
+dirs.workspace = true
+fd-lock.workspace = true
+forc-tracing.workspace = true
+fuel-tx = { workspace = true, optional = true }
+hex.workspace = true
+paste.workspace = true
+regex.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+serial_test.workspace = true
+sway-core.workspace = true
+sway-error.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = [
     "ansi",
     "env-filter",
     "json",
 ] }
-unicode-xid = "0.2.2"
+unicode-xid.workspace = true
 
 [features]
 default = ["fuel-tx"]
diff --git a/forc-util/src/fs_locking.rs b/forc-util/src/fs_locking.rs
index 23772bc6d30..8e6f438337b 100644
--- a/forc-util/src/fs_locking.rs
+++ b/forc-util/src/fs_locking.rs
@@ -35,7 +35,7 @@ impl PidFileLocking {
     }
 
     /// Checks if the given pid is active
-    #[cfg(not(target = "windows"))]
+    #[cfg(not(target_os = "windows"))]
     fn is_pid_active(pid: usize) -> bool {
         // Not using sysinfo here because it has compatibility issues with fuel.nix
         // https://github.com/FuelLabs/fuel.nix/issues/64
@@ -50,7 +50,7 @@ impl PidFileLocking {
         output_str.contains(&format!("{} ", pid))
     }
 
-    #[cfg(target = "windows")]
+    #[cfg(target_os = "windows")]
     fn is_pid_active(pid: usize) -> bool {
         // Not using sysinfo here because it has compatibility issues with fuel.nix
         // https://github.com/FuelLabs/fuel.nix/issues/64
diff --git a/forc-util/src/lib.rs b/forc-util/src/lib.rs
index da996311fc2..7cf7f45b2b4 100644
--- a/forc-util/src/lib.rs
+++ b/forc-util/src/lib.rs
@@ -3,9 +3,8 @@ use annotate_snippets::{
     renderer::{AnsiColor, Style},
     Annotation, AnnotationType, Renderer, Slice, Snippet, SourceAnnotation,
 };
-use ansi_term::Colour;
 use anyhow::{bail, Context, Result};
-use forc_tracing::{println_error, println_red_err, println_yellow_err};
+use forc_tracing::{println_action_green, println_error, println_red_err, println_yellow_err};
 use std::{
     collections::{hash_map, HashSet},
     fmt::Display,
@@ -346,10 +345,9 @@ pub fn print_compiling(ty: Option<&TreeType>, name: &str, src: &dyn std::fmt::Di
         Some(ty) => format!("{} ", program_type_str(ty)),
         None => "".to_string(),
     };
-    tracing::debug!(
-        " {} {ty}{} ({src})",
-        Colour::Green.bold().paint("Compiling"),
-        ansi_term::Style::new().bold().paint(name)
+    println_action_green(
+        "Compiling",
+        &format!("{ty}{} ({src})", ansi_term::Style::new().bold().paint(name)),
     );
 }
 
@@ -718,43 +716,104 @@ fn construct_window<'a>(
     let total_lines_of_highlight = end.line - start.line;
     debug_assert!(total_lines_in_input >= total_lines_of_highlight);
 
-    let mut current_line = 0;
-    let mut lines_to_start_of_snippet = 0;
-    let mut calculated_start_ix = None;
-    let mut calculated_end_ix = None;
-    let mut pos = 0;
-    for character in input.chars() {
+    let mut current_line = 1usize;
+
+    let mut chars = input.char_indices().map(|(char_offset, character)| {
+        let r = (current_line, char_offset);
         if character == '\n' {
-            current_line += 1
+            current_line += 1;
         }
+        r
+    });
 
-        if current_line + NUM_LINES_BUFFER >= start.line && calculated_start_ix.is_none() {
-            calculated_start_ix = Some(pos);
-            lines_to_start_of_snippet = current_line;
-        }
+    // Find the first char of the first line
+    let first_char = chars
+        .by_ref()
+        .find(|(current_line, _)| current_line + NUM_LINES_BUFFER >= start.line);
 
-        if current_line >= end.line + NUM_LINES_BUFFER && calculated_end_ix.is_none() {
-            calculated_end_ix = Some(pos);
-        }
+    // Find the last char of the last line
+    let last_char = chars
+        .by_ref()
+        .find(|(current_line, _)| *current_line > end.line + NUM_LINES_BUFFER)
+        .map(|x| x.1);
 
-        if calculated_start_ix.is_some() && calculated_end_ix.is_some() {
-            break;
+    // this releases the borrow of `current_line`
+    drop(chars);
+
+    let (first_char_line, first_char_offset, last_char_offset) = match (first_char, last_char) {
+        // has first and last
+        (Some((first_char_line, first_char_offset)), Some(last_char_offset)) => {
+            (first_char_line, first_char_offset, last_char_offset)
         }
-        pos += character.len_utf8();
+        // has first and no last
+        (Some((first_char_line, first_char_offset)), None) => {
+            (first_char_line, first_char_offset, input.len())
+        }
+        // others
+        _ => (current_line, input.len(), input.len()),
+    };
+
+    // adjust indices to be inside the returned window
+    start.line = first_char_line;
+    *start_ix = start_ix.saturating_sub(first_char_offset);
+    *end_ix = end_ix.saturating_sub(first_char_offset);
+
+    &input[first_char_offset..last_char_offset]
+}
+
+#[test]
+fn ok_construct_window() {
+    fn t(
+        start_line: usize,
+        start_col: usize,
+        end_line: usize,
+        end_col: usize,
+        start_char: usize,
+        end_char: usize,
+        input: &str,
+    ) -> (usize, usize, &str) {
+        let mut s = LineCol {
+            line: start_line,
+            col: start_col,
+        };
+        let mut start = start_char;
+        let mut end = end_char;
+        let r = construct_window(
+            &mut s,
+            LineCol {
+                line: end_line,
+                col: end_col,
+            },
+            &mut start,
+            &mut end,
+            input,
+        );
+        (start, end, r)
     }
-    let calculated_start_ix = calculated_start_ix.unwrap_or(0);
-    let calculated_end_ix = calculated_end_ix.unwrap_or(input.len());
 
-    let start_ix_bytes = *start_ix - std::cmp::min(calculated_start_ix, *start_ix);
-    let end_ix_bytes = *end_ix - std::cmp::min(calculated_start_ix, *end_ix);
-    // We want the start_ix and end_ix in terms of chars and not bytes, so translate.
-    *start_ix = input[calculated_start_ix..(calculated_start_ix + start_ix_bytes)]
-        .chars()
-        .count();
-    *end_ix = input[calculated_start_ix..(calculated_start_ix + end_ix_bytes)]
-        .chars()
-        .count();
-
-    start.line = lines_to_start_of_snippet;
-    &input[calculated_start_ix..calculated_end_ix]
+    // Invalid Empty file
+    assert_eq!(t(0, 0, 0, 0, 0, 0, ""), (0, 0, ""));
+
+    // Valid Empty File
+    assert_eq!(t(1, 1, 1, 1, 0, 0, ""), (0, 0, ""));
+
+    // One line, error after the last char
+    assert_eq!(t(1, 7, 1, 7, 6, 6, "script"), (6, 6, "script"));
+
+    //                       01 23 45 67 89 AB CD E
+    let eight_lines = "1\n2\n3\n4\n5\n6\n7\n8";
+
+    assert_eq!(t(1, 1, 1, 1, 0, 1, eight_lines), (0, 1, "1\n2\n3\n"));
+    assert_eq!(t(2, 1, 2, 1, 2, 3, eight_lines), (2, 3, "1\n2\n3\n4\n"));
+    assert_eq!(t(3, 1, 3, 1, 4, 5, eight_lines), (4, 5, "1\n2\n3\n4\n5\n"));
+    assert_eq!(t(4, 1, 4, 1, 6, 7, eight_lines), (4, 5, "2\n3\n4\n5\n6\n"));
+    assert_eq!(t(5, 1, 5, 1, 8, 9, eight_lines), (4, 5, "3\n4\n5\n6\n7\n"));
+    assert_eq!(t(6, 1, 6, 1, 10, 11, eight_lines), (4, 5, "4\n5\n6\n7\n8"));
+    assert_eq!(t(7, 1, 7, 1, 12, 13, eight_lines), (4, 5, "5\n6\n7\n8"));
+    assert_eq!(t(8, 1, 8, 1, 14, 15, eight_lines), (4, 5, "6\n7\n8"));
+
+    // Invalid lines
+    assert_eq!(t(9, 1, 9, 1, 14, 15, eight_lines), (2, 3, "7\n8"));
+    assert_eq!(t(10, 1, 10, 1, 14, 15, eight_lines), (0, 1, "8"));
+    assert_eq!(t(11, 1, 11, 1, 14, 15, eight_lines), (0, 0, ""));
 }
diff --git a/forc/Cargo.toml b/forc/Cargo.toml
index 8f6c5aa04e7..2f5d6dda481 100644
--- a/forc/Cargo.toml
+++ b/forc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "forc"
-version = "0.60.0"
+version.workspace = true
 description = "Fuel Orchestrator."
 authors.workspace = true
 edition.workspace = true
@@ -17,35 +17,35 @@ name = "forc"
 path = "src/main.rs"
 
 [dependencies]
-annotate-snippets = { version = "0.10.1" }
-ansi_term = "0.12"
-anyhow = "1.0.41"
-clap = { version = "4.5.4", features = ["cargo", "derive", "env"] }
-clap_complete = "4.5.2"
-clap_complete_fig = "4.5.0"
-forc-pkg = { version = "0.60.0", path = "../forc-pkg" }
-forc-test = { version = "0.60.0", path = "../forc-test" }
-forc-tracing = { version = "0.60.0", path = "../forc-tracing" }
-forc-util = { version = "0.60.0", path = "../forc-util" }
-fs_extra = "1.2"
-fuel-asm = { workspace = true }
-hex = "0.4.3"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.73"
-sway-core = { version = "0.60.0", path = "../sway-core" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-ir = { version = "0.60.0", path = "../sway-ir" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-term-table = "1.3"
-tokio = { version = "1.8.0", features = ["macros", "rt-multi-thread"] }
-toml = { version = "0.7", features = ["parse"] }
-toml_edit = "0.19"
-tracing = "0.1"
-url = "2.2"
-uwuify = { version = "^0.2", optional = true }
-walkdir = "2.3"
-whoami = "1.1"
+annotate-snippets.workspace = true
+ansi_term.workspace = true
+anyhow.workspace = true
+clap = { workspace = true, features = ["cargo", "derive", "env"] }
+clap_complete.workspace = true
+clap_complete_fig.workspace = true
+forc-pkg.workspace = true
+forc-test.workspace = true
+forc-tracing.workspace = true
+forc-util.workspace = true
+fs_extra.workspace = true
+fuel-asm.workspace = true
+hex.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+sway-core.workspace = true
+sway-error.workspace = true
+sway-ir.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+term-table.workspace = true
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+toml = { workspace = true, features = ["parse"] }
+toml_edit.workspace = true
+tracing.workspace = true
+url.workspace = true
+uwuify = { workspace = true, optional = true }
+walkdir.workspace = true
+whoami.workspace = true
 
 [features]
 default = []
@@ -55,3 +55,4 @@ uwu = ["uwuify"]
 
 [dev-dependencies]
 completest-pty = "0.5.0"
+rexpect = "0.5"
diff --git a/forc/src/cli/commands/completions.rs b/forc/src/cli/commands/completions.rs
index ffa06fa9286..cf4b0160173 100644
--- a/forc/src/cli/commands/completions.rs
+++ b/forc/src/cli/commands/completions.rs
@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use clap::{Command as ClapCommand, CommandFactory, Parser};
 use clap_complete::{generate, Generator, Shell};
 use forc_util::ForcResult;
@@ -18,16 +20,20 @@ enum Target {
     Fig,
 }
 
-impl ToString for Target {
-    fn to_string(&self) -> String {
-        match self {
-            Target::Bash => "bash".to_string(),
-            Target::Elvish => "elvish".to_string(),
-            Target::Fish => "fish".to_string(),
-            Target::PowerShell => "powershell".to_string(),
-            Target::Zsh => "zsh".to_string(),
-            Target::Fig => "fig".to_string(),
-        }
+impl Display for Target {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Target::Bash => "bash".to_string(),
+                Target::Elvish => "elvish".to_string(),
+                Target::Fish => "fish".to_string(),
+                Target::PowerShell => "powershell".to_string(),
+                Target::Zsh => "zsh".to_string(),
+                Target::Fig => "fig".to_string(),
+            }
+        )
     }
 }
 
diff --git a/forc/src/cli/commands/parse_bytecode.rs b/forc/src/cli/commands/parse_bytecode.rs
index 2b8957e3f2c..f4a30c82d6d 100644
--- a/forc/src/cli/commands/parse_bytecode.rs
+++ b/forc/src/cli/commands/parse_bytecode.rs
@@ -62,7 +62,10 @@ pub(crate) fn exec(command: Command) -> ForcResult<()> {
             Ok(_) | Err(fuel_asm::InvalidOpcode) => "".into(),
         };
         table.add_row(Row::new(vec![
-            TableCell::new_with_alignment(word_ix, 1, Alignment::Right),
+            TableCell::builder(word_ix)
+                .col_span(1)
+                .alignment(Alignment::Right)
+                .build(),
             TableCell::new(word_ix * 4),
             TableCell::new(match result {
                 Ok(inst) => format!("{inst:?}"),
diff --git a/forc/src/cli/commands/test.rs b/forc/src/cli/commands/test.rs
index f8e4001fa42..5ffa1c51d75 100644
--- a/forc/src/cli/commands/test.rs
+++ b/forc/src/cli/commands/test.rs
@@ -3,6 +3,7 @@ use ansi_term::Colour;
 use clap::Parser;
 use forc_pkg as pkg;
 use forc_test::{decode_log_data, TestFilter, TestRunnerCount, TestedPackage};
+use forc_tracing::println_action_green;
 use forc_util::{tx_utils::format_log_receipts, ForcError, ForcResult};
 use pkg::manifest::build_profile::ExperimentalFlags;
 use sway_core::fuel_prelude::fuel_tx::Receipt;
@@ -60,16 +61,15 @@ pub struct Command {
 #[derive(Parser, Debug, Clone)]
 #[clap(after_help = help())]
 pub struct TestPrintOpts {
-    #[clap(long = "pretty-print", short = 'r')]
+    #[clap(long = "pretty")]
     /// Pretty-print the logs emitted from tests.
     pub pretty_print: bool,
     /// Print `Log` and `LogData` receipts for tests.
     #[clap(long = "logs", short = 'l')]
     pub print_logs: bool,
-    /// Decode logs and show decoded log information in human readable format alongside the raw
-    /// logs.
-    #[clap(long = "decode", short = 'd')]
-    pub decode_logs: bool,
+    /// Print the raw logs for tests.
+    #[clap(long)]
+    pub raw_logs: bool,
 }
 
 pub(crate) fn exec(cmd: Command) -> ForcResult<()> {
@@ -90,12 +90,15 @@ pub(crate) fn exec(cmd: Command) -> ForcResult<()> {
     let test_count = built_tests.test_count(test_filter.as_ref());
     let num_tests_running = test_count.total - test_count.ignored;
     let num_tests_ignored = test_count.ignored;
-    info!(
-        "   Running {} {}, filtered {} {}",
-        num_tests_running,
-        formatted_test_count_string(&num_tests_running),
-        num_tests_ignored,
-        formatted_test_count_string(&num_tests_ignored)
+    println_action_green(
+        "Running",
+        &format!(
+            "{} {}, filtered {} {}",
+            num_tests_running,
+            formatted_test_count_string(&num_tests_running),
+            num_tests_ignored,
+            formatted_test_count_string(&num_tests_ignored)
+        ),
     );
     let tested = built_tests.run(test_runner_count, test_filter)?;
     let duration = start.elapsed();
@@ -105,10 +108,11 @@ pub(crate) fn exec(cmd: Command) -> ForcResult<()> {
         forc_test::Tested::Workspace(pkgs) => {
             for pkg in &pkgs {
                 let built = &pkg.built.descriptor.name;
-                info!("\n   tested -- {built}\n");
+                info!("\ntested -- {built}\n");
                 print_tested_pkg(pkg, &test_print_opts)?;
             }
-            info!("\n   Finished in {:?}", duration);
+            info!("");
+            println_action_green("Finished", &format!("in {:?}", duration));
             pkgs.iter().all(|pkg| pkg.tests_passed())
         }
         forc_test::Tested::Package(pkg) => {
@@ -145,26 +149,26 @@ fn print_tested_pkg(pkg: &TestedPackage, test_print_opts: &TestPrintOpts) -> For
         );
 
         // If logs are enabled, print them.
+        let logs = &test.logs;
         if test_print_opts.print_logs {
-            let logs = &test.logs;
-            if test_print_opts.decode_logs {
-                for log in logs {
-                    if let Receipt::LogData {
-                        rb,
-                        data: Some(data),
-                        ..
-                    } = log
-                    {
-                        let decoded_log_data =
-                            decode_log_data(&rb.to_string(), data, &pkg.built.program_abi)?;
-                        let var_value = decoded_log_data.value;
-                        info!("Decoded log value: {}, log rb: {}", var_value, rb);
-                    }
+            for log in logs {
+                if let Receipt::LogData {
+                    rb,
+                    data: Some(data),
+                    ..
+                } = log
+                {
+                    let decoded_log_data =
+                        decode_log_data(&rb.to_string(), data, &pkg.built.program_abi)?;
+                    let var_value = decoded_log_data.value;
+                    info!("Decoded log value: {}, log rb: {}", var_value, rb);
                 }
-                info!("Raw logs:");
             }
+        }
+
+        if test_print_opts.raw_logs {
             let formatted_logs = format_log_receipts(logs, test_print_opts.pretty_print)?;
-            info!("{}", formatted_logs);
+            info!("Raw logs:\n{}", formatted_logs);
         }
 
         // If the test is failing, save the test result for printing the details later on.
@@ -210,7 +214,7 @@ fn print_tested_pkg(pkg: &TestedPackage, test_print_opts: &TestPrintOpts) -> For
         .map(|test_result| test_result.duration)
         .sum();
     info!(
-        "   Result: {}. {} passed. {} failed. Finished in {:?}.",
+        "\ntest result: {}. {} passed; {} failed; finished in {:?}",
         color.paint(state),
         succeeded,
         failed,
@@ -228,7 +232,6 @@ fn opts_from_cmd(cmd: Command) -> forc_test::TestOpts {
             terse: cmd.build.pkg.terse,
             locked: cmd.build.pkg.locked,
             output_directory: cmd.build.pkg.output_directory,
-            json_abi_with_callpaths: cmd.build.pkg.json_abi_with_callpaths,
             ipfs_node: cmd.build.pkg.ipfs_node.unwrap_or_default(),
         },
         print: pkg::PrintOpts {
@@ -237,6 +240,7 @@ fn opts_from_cmd(cmd: Command) -> forc_test::TestOpts {
             dca_graph_url_format: cmd.build.print.dca_graph_url_format.clone(),
             asm: cmd.build.print.asm(),
             bytecode: cmd.build.print.bytecode,
+            bytecode_spans: false,
             ir: cmd.build.print.ir(),
             reverse_order: cmd.build.print.reverse_order,
         },
diff --git a/forc/src/cli/shared.rs b/forc/src/cli/shared.rs
index 313edcd08b1..28b38465df3 100644
--- a/forc/src/cli/shared.rs
+++ b/forc/src/cli/shared.rs
@@ -150,9 +150,6 @@ pub struct Pkg {
     /// If the lock file is missing, or it needs to be updated, Forc will exit with an error.
     #[clap(long)]
     pub locked: bool,
-    /// Outputs JSON ABI with callpaths instead of only names for structs and enums.
-    #[clap(long)]
-    pub json_abi_with_callpaths: bool,
     /// The IPFS node to use for fetching IPFS sources.
     ///
     /// [possible values: PUBLIC, LOCAL, <GATEWAY_URL>]
diff --git a/forc/src/ops/forc_build.rs b/forc/src/ops/forc_build.rs
index 35a03b611a7..49c0c27f955 100644
--- a/forc/src/ops/forc_build.rs
+++ b/forc/src/ops/forc_build.rs
@@ -17,7 +17,6 @@ fn opts_from_cmd(cmd: BuildCommand) -> pkg::BuildOpts {
             terse: cmd.build.pkg.terse,
             locked: cmd.build.pkg.locked,
             output_directory: cmd.build.pkg.output_directory,
-            json_abi_with_callpaths: cmd.build.pkg.json_abi_with_callpaths,
             ipfs_node: cmd.build.pkg.ipfs_node.unwrap_or_default(),
         },
         print: pkg::PrintOpts {
@@ -26,6 +25,7 @@ fn opts_from_cmd(cmd: BuildCommand) -> pkg::BuildOpts {
             dca_graph_url_format: cmd.build.print.dca_graph_url_format.clone(),
             asm: cmd.build.print.asm(),
             bytecode: cmd.build.print.bytecode,
+            bytecode_spans: false,
             ir: cmd.build.print.ir(),
             reverse_order: cmd.build.print.reverse_order,
         },
diff --git a/forc/src/ops/forc_contract_id.rs b/forc/src/ops/forc_contract_id.rs
index 3a6d975ac40..f81441637a5 100644
--- a/forc/src/ops/forc_contract_id.rs
+++ b/forc/src/ops/forc_contract_id.rs
@@ -8,7 +8,7 @@ use tracing::info;
 
 pub fn contract_id(command: ContractIdCommand) -> Result<()> {
     let build_options = build_opts_from_cmd(&command);
-    let build_plan = pkg::BuildPlan::from_build_opts(&build_options)?;
+    let build_plan = pkg::BuildPlan::from_pkg_opts(&build_options.pkg)?;
     // If a salt was specified but we have more than one member to build, there
     // may be ambiguity in how the salt should be applied, especially if the
     // workspace contains multiple contracts, and especially if one contract
@@ -52,7 +52,6 @@ fn build_opts_from_cmd(cmd: &ContractIdCommand) -> pkg::BuildOpts {
             terse: cmd.pkg.terse,
             locked: cmd.pkg.locked,
             output_directory: cmd.pkg.output_directory.clone(),
-            json_abi_with_callpaths: cmd.pkg.json_abi_with_callpaths,
             ipfs_node: cmd.pkg.ipfs_node.clone().unwrap_or_default(),
         },
         print: pkg::PrintOpts {
@@ -61,6 +60,7 @@ fn build_opts_from_cmd(cmd: &ContractIdCommand) -> pkg::BuildOpts {
             dca_graph_url_format: cmd.print.dca_graph_url_format.clone(),
             asm: cmd.print.asm(),
             bytecode: cmd.print.bytecode,
+            bytecode_spans: false,
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
diff --git a/forc/src/ops/forc_predicate_root.rs b/forc/src/ops/forc_predicate_root.rs
index febf7b96ca6..1381aec392e 100644
--- a/forc/src/ops/forc_predicate_root.rs
+++ b/forc/src/ops/forc_predicate_root.rs
@@ -21,7 +21,6 @@ fn build_opts_from_cmd(cmd: PredicateRootCommand) -> pkg::BuildOpts {
             terse: cmd.pkg.terse,
             locked: cmd.pkg.locked,
             output_directory: cmd.pkg.output_directory.clone(),
-            json_abi_with_callpaths: cmd.pkg.json_abi_with_callpaths,
             ipfs_node: cmd.pkg.ipfs_node.unwrap_or_default(),
         },
         print: pkg::PrintOpts {
@@ -30,6 +29,7 @@ fn build_opts_from_cmd(cmd: PredicateRootCommand) -> pkg::BuildOpts {
             dca_graph_url_format: cmd.print.dca_graph_url_format.clone(),
             asm: cmd.print.asm(),
             bytecode: cmd.print.bytecode,
+            bytecode_spans: false,
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
diff --git a/forc/src/ops/forc_template.rs b/forc/src/ops/forc_template.rs
index 07a0b5846bb..0304a9d298a 100644
--- a/forc/src/ops/forc_template.rs
+++ b/forc/src/ops/forc_template.rs
@@ -4,6 +4,7 @@ use forc_pkg::{
     manifest::{self, PackageManifest},
     source::{self, git::Url},
 };
+use forc_tracing::println_action_green;
 use forc_util::validate_project_name;
 use fs_extra::dir::{copy, CopyOptions};
 use std::fs::File;
@@ -11,7 +12,6 @@ use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 use std::{env, str::FromStr};
 use sway_utils::constants;
-use tracing::info;
 
 pub fn init(command: TemplateCommand) -> Result<()> {
     validate_project_name(&command.project_name)?;
@@ -31,7 +31,7 @@ pub fn init(command: TemplateCommand) -> Result<()> {
     let fetch_ts = std::time::Instant::now();
     let fetch_id = source::fetch_id(current_dir, fetch_ts);
 
-    info!("Resolving the HEAD of {}", source.repo);
+    println_action_green("Resolving", &format!("the HEAD of {}", source.repo));
     let git_source = source::git::pin(fetch_id, &local_repo_name, source)?;
 
     let repo_path = source::git::commit_path(
@@ -40,7 +40,7 @@ pub fn init(command: TemplateCommand) -> Result<()> {
         &git_source.commit_hash,
     );
     if !repo_path.exists() {
-        info!("  Fetching {}", git_source.to_string());
+        println_action_green("Fetching", git_source.to_string().as_str());
         source::git::fetch(fetch_id, &local_repo_name, &git_source)?;
     }
 
@@ -65,7 +65,10 @@ pub fn init(command: TemplateCommand) -> Result<()> {
     // Create the target dir
     let target_dir = current_dir.join(&command.project_name);
 
-    info!("Creating {} from template", &command.project_name);
+    println_action_green(
+        "Creating",
+        &format!("{} from template", &command.project_name),
+    );
     // Copy contents from template to target dir
     copy_template_to_target(&from_path, &target_dir)?;
 
@@ -81,7 +84,7 @@ fn edit_forc_toml(out_dir: &Path, project_name: &str, real_name: &str) -> Result
     let mut file = File::open(out_dir.join(constants::MANIFEST_FILE_NAME))?;
     let mut toml = String::new();
     file.read_to_string(&mut toml)?;
-    let mut manifest_toml = toml.parse::<toml_edit::Document>()?;
+    let mut manifest_toml = toml.parse::<toml_edit::DocumentMut>()?;
 
     let mut authors = Vec::new();
     let forc_toml: toml::Value = toml::de::from_str(&toml)?;
@@ -141,7 +144,7 @@ fn edit_cargo_toml(out_dir: &Path, project_name: &str, real_name: &str) -> Resul
     }
     updated_authors.push(real_name);
 
-    let mut manifest_toml = toml.parse::<toml_edit::Document>()?;
+    let mut manifest_toml = toml.parse::<toml_edit::DocumentMut>()?;
     manifest_toml["package"]["authors"] = toml_edit::value(updated_authors);
     manifest_toml["package"]["name"] = toml_edit::value(project_name);
 
diff --git a/forc/tests/cli_integration.rs b/forc/tests/cli_integration.rs
new file mode 100644
index 00000000000..407cda7489d
--- /dev/null
+++ b/forc/tests/cli_integration.rs
@@ -0,0 +1,84 @@
+use std::path::PathBuf;
+
+use rexpect::spawn;
+
+const TIMEOUT_MS: u64 = 300000;
+
+fn test_fixtures_path() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .canonicalize()
+        .unwrap()
+}
+
+#[test]
+fn test_forc_test_decoded_logs() -> Result<(), rexpect::error::Error> {
+    // Spawn the forc binary using cargo run
+    let project_dir = test_fixtures_path().join("test_contract");
+    let mut process = spawn(
+        &format!(
+            "cargo run --bin forc -- test --logs --path {}",
+            project_dir.to_string_lossy()
+        ),
+        Some(TIMEOUT_MS),
+    )?;
+
+    // Assert that the output is correct
+    process.exp_string("      test test_log_4")?;
+    process.exp_string("Decoded log value: 4, log rb: 1515152261580153489")?;
+    process.exp_string("      test test_log_2")?;
+    process.exp_string("Decoded log value: 2, log rb: 1515152261580153489")?;
+
+    process.process.exit()?;
+    Ok(())
+}
+
+#[test]
+fn test_forc_test_raw_logs() -> Result<(), rexpect::error::Error> {
+    // Spawn the forc binary using cargo run
+    let project_dir = test_fixtures_path().join("test_contract");
+    let mut process = spawn(
+        &format!(
+            "cargo run --bin forc -- test --raw-logs --path {}",
+            project_dir.to_string_lossy()
+        ),
+        Some(TIMEOUT_MS),
+    )?;
+
+    // Assert that the output is correct
+    process.exp_string("      test test_log_4")?;
+    process.exp_string("Raw logs:")?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12652,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.exp_string("      test test_log_2")?;
+    process.exp_string("Raw logs:")?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12652,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+
+    process.process.exit()?;
+    Ok(())
+}
+
+#[test]
+fn test_forc_test_both_logs() -> Result<(), rexpect::error::Error> {
+    // Spawn the forc binary using cargo run
+    let project_dir = test_fixtures_path().join("test_contract");
+    let mut process = spawn(
+        &format!(
+            "cargo run --bin forc -- test --logs --raw-logs --path {}",
+            project_dir.to_string_lossy()
+        ),
+        Some(TIMEOUT_MS),
+    )?;
+
+    // Assert that the output is correct
+    process.exp_string("      test test_log_4")?;
+    process.exp_string("Decoded log value: 4, log rb: 1515152261580153489")?;
+    process.exp_string("Raw logs:")?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12652,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.exp_string("      test test_log_2")?;
+    process.exp_string("Decoded log value: 2, log rb: 1515152261580153489")?;
+    process.exp_string("Raw logs:")?;
+    process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12652,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?;
+    process.process.exit()?;
+    Ok(())
+}
diff --git a/forc/tests/fixtures/test_contract/.gitignore b/forc/tests/fixtures/test_contract/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/forc/tests/fixtures/test_contract/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/forc/tests/fixtures/test_contract/Forc.lock b/forc/tests/fixtures/test_contract/Forc.lock
new file mode 100644
index 00000000000..943d47b39ef
--- /dev/null
+++ b/forc/tests/fixtures/test_contract/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-4D4735C41181917E"
+
+[[package]]
+name = "std"
+source = "path+from-root-4D4735C41181917E"
+dependencies = ["core"]
+
+[[package]]
+name = "test_contract"
+source = "member"
+dependencies = ["std"]
diff --git a/forc/tests/fixtures/test_contract/Forc.toml b/forc/tests/fixtures/test_contract/Forc.toml
new file mode 100644
index 00000000000..4342f8dbc65
--- /dev/null
+++ b/forc/tests/fixtures/test_contract/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "test_contract"
+
+[dependencies]
+std = { path = "../../../../sway-lib-std/" }
diff --git a/forc-plugins/forc-client/test/data/standalone_contract_b/src/main.sw b/forc/tests/fixtures/test_contract/src/main.sw
similarity index 56%
rename from forc-plugins/forc-client/test/data/standalone_contract_b/src/main.sw
rename to forc/tests/fixtures/test_contract/src/main.sw
index 7d4a75493c6..2314fa4dc47 100644
--- a/forc-plugins/forc-client/test/data/standalone_contract_b/src/main.sw
+++ b/forc/tests/fixtures/test_contract/src/main.sw
@@ -9,3 +9,15 @@ impl MyContract for Contract {
         true
     }
 }
+
+#[test]
+fn test_log_4() {
+  log(4);
+  assert(1 == 1)
+}
+
+#[test]
+fn test_log_2() {
+  log(2);
+  assert(1 == 1)
+}
diff --git a/scripts/mdbook-forc-documenter/Cargo.toml b/scripts/mdbook-forc-documenter/Cargo.toml
index eae79eff1ef..8db19ab6db6 100644
--- a/scripts/mdbook-forc-documenter/Cargo.toml
+++ b/scripts/mdbook-forc-documenter/Cargo.toml
@@ -13,9 +13,9 @@ name = "mdbook_forc_documenter"
 path = "src/lib.rs"
 
 [dependencies]
-anyhow = "1"
-clap = { version = "4.5.4", features = ["derive"] }
-mdbook = { version = "0.4", default-features = false }
-semver = "1.0"
-serde = "1.0"
-serde_json = "1.0"
+anyhow.workspace = true
+clap = { workspace = true, features = ["derive"] }
+mdbook.workspace = true
+semver.workspace = true
+serde.workspace = true
+serde_json.workspace = true
diff --git a/scripts/mdbook-forc-documenter/src/bin/mdbook-forc-documenter.rs b/scripts/mdbook-forc-documenter/src/bin/mdbook-forc-documenter.rs
index b273e9550db..1de59586abf 100644
--- a/scripts/mdbook-forc-documenter/src/bin/mdbook-forc-documenter.rs
+++ b/scripts/mdbook-forc-documenter/src/bin/mdbook-forc-documenter.rs
@@ -1,18 +1,21 @@
 use clap::{Arg, ArgMatches, Command};
 use mdbook::errors::Error;
 use mdbook::preprocess::{CmdPreprocessor, Preprocessor};
+use mdbook_forc_documenter::ForcDocumenter;
 use semver::{Version, VersionReq};
 use std::io;
 use std::process;
 
-use mdbook_forc_documenter::ForcDocumenter;
-
 pub fn make_app() -> Command {
     Command::new("forc-documenter")
         .about("A mdbook preprocessor which documents Forc commands")
         .subcommand(
             Command::new("supports")
-                .arg(Arg::new("renderer").required(true))
+                .arg(
+                    Arg::new("renderer")
+                        .required(true)
+                        .value_parser(clap::value_parser!(String)),
+                )
                 .about("Check whether a renderer is supported by this preprocessor"),
         )
 }
@@ -53,7 +56,7 @@ fn handle_preprocessing(pre: &dyn Preprocessor) -> Result<(), Error> {
 }
 
 fn handle_supports(pre: &dyn Preprocessor, sub_args: &ArgMatches) -> ! {
-    let renderer: &Option<&str> = sub_args.get_one("renderer").expect("Required argument");
+    let renderer = sub_args.get_one::<String>("renderer").map(String::as_str);
     let supported = renderer.map(|r| pre.supports_renderer(r)).unwrap_or(false);
 
     // Signal whether the renderer is supported by exiting with 1 or 0.
diff --git a/scripts/mdbook-forc-documenter/src/commands.rs b/scripts/mdbook-forc-documenter/src/commands.rs
index afbda6ae985..4f1723fc9d8 100644
--- a/scripts/mdbook-forc-documenter/src/commands.rs
+++ b/scripts/mdbook-forc-documenter/src/commands.rs
@@ -1,11 +1,8 @@
 use crate::formatter::{format_header_line, format_line};
 use anyhow::{anyhow, Result};
-use std::collections::HashMap;
-use std::ffi::OsString;
-use std::process;
+use std::{collections::HashMap, ffi::OsString, process};
 
 pub fn possible_forc_commands() -> Vec<String> {
-    let mut possible_commands = Vec::new();
     let output = process::Command::new("forc")
         .arg("--help")
         .output()
@@ -14,18 +11,27 @@ pub fn possible_forc_commands() -> Vec<String> {
     let output_str = String::from_utf8_lossy(&output.stdout);
     let lines = output_str.lines();
 
-    let mut has_parsed_subcommand_header = false;
+    let mut possible_commands = Vec::new();
+    let mut in_commands_section = false;
 
     for line in lines {
-        if has_parsed_subcommand_header {
-            let (command, _) = line.trim().split_once(' ').unwrap_or(("", ""));
-            possible_commands.push(command.to_string());
+        if line.trim() == "Commands:" {
+            // Start of commands section
+            in_commands_section = true;
+            continue;
         }
-        if line == "SUBCOMMANDS:" {
-            has_parsed_subcommand_header = true;
+
+        if in_commands_section {
+            if line.trim().is_empty() || line.trim().starts_with("Options:") {
+                // End of commands section
+                break;
+            }
+            // Extract command name (first word of the line)
+            if let Some(command) = line.split_whitespace().next() {
+                possible_commands.push(command.to_string());
+            }
         }
     }
-
     possible_commands
 }
 
diff --git a/scripts/mdbook-forc-documenter/src/formatter.rs b/scripts/mdbook-forc-documenter/src/formatter.rs
index d21298363d5..883df32b82f 100644
--- a/scripts/mdbook-forc-documenter/src/formatter.rs
+++ b/scripts/mdbook-forc-documenter/src/formatter.rs
@@ -110,7 +110,7 @@ fn format_option_line(option_line: &str) -> String {
                     a
                 })
                 .trim()
-                .to_owned();
+                .to_string();
             break;
         }
     }
diff --git a/sway-ast/Cargo.toml b/sway-ast/Cargo.toml
index 1f031a959cc..ad73333213d 100644
--- a/sway-ast/Cargo.toml
+++ b/sway-ast/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-ast"
-version = "0.60.0"
+version.workspace = true
 description = "Sway's AST"
 authors.workspace = true
 edition.workspace = true
@@ -9,12 +9,12 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-extension-trait = "1.0.1"
-num-bigint = { version = "0.4.3", features = ["serde"] }
-num-traits = "0.2.14"
-serde = { version = "1.0", features = ["derive"] }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
+extension-trait.workspace = true
+num-bigint = { workspace = true, features = ["serde"] }
+num-traits.workspace = true
+serde = { workspace = true, features = ["derive"] }
+sway-error.workspace = true
+sway-types.workspace = true
 
 [lints.clippy]
 iter_over_hash_type = "deny"
diff --git a/sway-ast/src/assignable.rs b/sway-ast/src/assignable.rs
index 0eedcc3bf45..a6a07eb8a9b 100644
--- a/sway-ast/src/assignable.rs
+++ b/sway-ast/src/assignable.rs
@@ -7,6 +7,7 @@ pub enum Assignable {
     /// E.g.:
     ///  - `my_variable`
     ///  - `array[0].field.x.1`
+    ///
     /// Note that within the path, we cannot have dereferencing
     /// (except, of course, in expressions inside of array index operator).
     /// This is guaranteed by the grammar.
diff --git a/sway-ast/src/expr/op_code.rs b/sway-ast/src/expr/op_code.rs
index 47f9665897b..acfc54411eb 100644
--- a/sway-ast/src/expr/op_code.rs
+++ b/sway-ast/src/expr/op_code.rs
@@ -200,6 +200,13 @@ define_op_codes!(
     (Srli, SrliOpcode, "srli", (ret: reg, lhs: reg, rhs: imm)),
     (Sub, SubOpcode, "sub", (ret: reg, lhs: reg, rhs: reg)),
     (Subi, SubiOpcode, "subi", (ret: reg, lhs: reg, rhs: imm)),
+    (Wqcm, WqcmOpcode, "wqcm", (ret: reg, lhs: reg, rhs: reg, op_mode: imm)),
+    (Wqop, WqopOpcode, "wqop", (ret: reg, lhs: reg, rhs: reg, op_mode: imm)),
+    (Wqml, WqmlOpcode, "wqml", (ret: reg, lhs: reg, rhs: reg, indirect: imm)),
+    (Wqdv, WqdvOpcode, "wqdv", (ret: reg, lhs: reg, rhs: reg, indirect: imm)),
+    (Wqmd, WqmdOpcode, "wqmd", (ret: reg, lhs_a: reg, lhs_b: reg, rhs: reg)),
+    (Wqam, WqamOpcode, "wqam", (ret: reg, lhs_a: reg, lhs_b: reg, rhs: reg)),
+    (Wqmm, WqmmOpcode, "wqmm", (ret: reg, lhs_a: reg, lhs_b: reg, rhs: reg)),
     (Xor, XorOpcode, "xor", (ret: reg, lhs: reg, rhs: reg)),
     (Xori, XoriOpcode, "xori", (ret: reg, lhs: reg, rhs: imm)),
     /* Control Flow Instructions */
@@ -259,7 +266,9 @@ define_op_codes!(
     ),
     (Croo, CrooOpcode, "croo", (addr: reg, contract: reg)),
     (Csiz, CsizOpcode, "csiz", (ret: reg, contract: reg)),
-    (Ldc, LdcOpcode, "ldc", (contract: reg, addr: reg, size: reg)),
+    (Bsiz, BsizOpcode, "bsiz", (ret: reg, contract: reg)),
+    (Ldc, LdcOpcode, "ldc", (contract: reg, addr: reg, size: reg, mode: imm)),
+    (Bldd, BlddOpcode, "bldd", (dst_ptr: reg, addr: reg, offset: reg, len: reg)),
     (
         Log,
         LogOpcode,
@@ -317,7 +326,7 @@ define_op_codes!(
     /* Cryptographic Instructions */
     (Eck1, Eck1Opcode, "eck1", (addr: reg, sig: reg, hash: reg)),
     (Ecr1, Ecr1Opcode, "ecr1", (addr: reg, sig: reg, hash: reg)),
-    (Ed19, Ed19Opcode, "ed19", (addr: reg, sig: reg, hash: reg)),
+    (Ed19, Ed19Opcode, "ed19", (addr: reg, sig: reg, hash: reg, len: reg)),
     (K256, K256Opcode, "k256", (addr: reg, data: reg, size: reg)),
     (S256, S256Opcode, "s256", (addr: reg, data: reg, size: reg)),
     /* Other Instructions */
diff --git a/sway-ast/src/intrinsics.rs b/sway-ast/src/intrinsics.rs
index 5200da142ae..182d47fa3d9 100644
--- a/sway-ast/src/intrinsics.rs
+++ b/sway-ast/src/intrinsics.rs
@@ -41,6 +41,8 @@ pub enum Intrinsic {
     EncodeBufferEmpty,      // let buffer: (raw_ptr, u64, u64) = __encode_buffer_empty()
     EncodeBufferAppend, // let buffer: (raw_ptr, u64, u64) = __encode_buffer_append(buffer, primitive data type)
     EncodeBufferAsRawSlice, // let slice: raw_slice = __encode_buffer_as_raw_slice(buffer)
+    Slice, // let ref_to_slice = __slice::<T: array or ref_to_slice>(item: T, inclusive_start_index, exclusive_end_index)
+    ElemAt, // let elem: &T = __elem_at::<T: array or ref_to_slice>(item: T, index)
 }
 
 impl fmt::Display for Intrinsic {
@@ -85,6 +87,8 @@ impl fmt::Display for Intrinsic {
             Intrinsic::EncodeBufferEmpty => "encode_buffer_empty",
             Intrinsic::EncodeBufferAppend => "encode_buffer_append",
             Intrinsic::EncodeBufferAsRawSlice => "encode_buffer_as_raw_slice",
+            Intrinsic::Slice => "slice",
+            Intrinsic::ElemAt => "elem_at",
         };
         write!(f, "{s}")
     }
@@ -133,6 +137,8 @@ impl Intrinsic {
             "__encode_buffer_empty" => EncodeBufferEmpty,
             "__encode_buffer_append" => EncodeBufferAppend,
             "__encode_buffer_as_raw_slice" => EncodeBufferAsRawSlice,
+            "__slice" => Slice,
+            "__elem_at" => ElemAt,
             _ => return None,
         })
     }
diff --git a/sway-ast/src/token.rs b/sway-ast/src/token.rs
index f834ad34792..31161a5f862 100644
--- a/sway-ast/src/token.rs
+++ b/sway-ast/src/token.rs
@@ -259,29 +259,6 @@ impl CharExt for char {
     }
 }
 
-struct CharIndicesInner<'a> {
-    src: &'a str,
-    position: usize,
-}
-
-impl<'a> Iterator for CharIndicesInner<'a> {
-    type Item = (usize, char);
-
-    fn next(&mut self) -> Option<(usize, char)> {
-        let mut char_indices = self.src[self.position..].char_indices();
-        let c = match char_indices.next() {
-            Some((_, c)) => c,
-            None => return None,
-        };
-        let ret = (self.position, c);
-        match char_indices.next() {
-            Some((char_width, _)) => self.position += char_width,
-            None => self.position = self.src.len(),
-        };
-        Some(ret)
-    }
-}
-
 impl TokenStream {
     pub fn token_trees(&self) -> &[TokenTree] {
         &self.token_trees
diff --git a/sway-ast/src/ty/mod.rs b/sway-ast/src/ty/mod.rs
index 3973a276372..7e2bbc35cab 100644
--- a/sway-ast/src/ty/mod.rs
+++ b/sway-ast/src/ty/mod.rs
@@ -19,7 +19,7 @@ pub enum Ty {
         ty: SquareBrackets<Box<Ty>>,
     },
     Slice {
-        slice_token: SliceToken,
+        slice_token: Option<SliceToken>,
         ty: SquareBrackets<Box<Ty>>,
     },
     Ref {
@@ -42,7 +42,12 @@ impl Spanned for Ty {
             Ty::StringArray { str_token, length } => Span::join(str_token.span(), &length.span()),
             Ty::Infer { underscore_token } => underscore_token.span(),
             Ty::Ptr { ptr_token, ty } => Span::join(ptr_token.span(), &ty.span()),
-            Ty::Slice { slice_token, ty } => Span::join(slice_token.span(), &ty.span()),
+            Ty::Slice { slice_token, ty } => {
+                let span = slice_token
+                    .as_ref()
+                    .map(|s| Span::join(s.span(), &ty.span()));
+                span.unwrap_or_else(|| ty.span())
+            }
             Ty::Ref {
                 ampersand_token,
                 mut_token: _,
diff --git a/sway-core/Cargo.toml b/sway-core/Cargo.toml
index 4c99385bbc2..668959fab61 100644
--- a/sway-core/Cargo.toml
+++ b/sway-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-core"
-version = "0.60.0"
+version.workspace = true
 description = "Sway core language."
 authors.workspace = true
 edition.workspace = true
@@ -9,46 +9,43 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-clap = { version = "4.5.4", features = ["derive"] }
-derivative = "2.2.0"
-dirs = "3.0"
-either = "1.9.0"
-ethabi = { package = "fuel-ethabi", version = "18.0.0" }
-etk-asm = { package = "fuel-etk-asm", version = "0.3.1-dev", features = [
-    "backtraces",
-] }
-etk-ops = { package = "fuel-etk-ops", version = "0.3.1-dev" }
-fuel-abi-types = { workspace = true }
+clap = { workspace = true, features = ["derive"] }
+derivative.workspace = true
+dirs.workspace = true
+either.workspace = true
+ethabi.workspace = true
+etk-asm = { workspace = true, features = ["backtraces"] }
+etk-ops.workspace = true
+fuel-abi-types.workspace = true
 fuel-vm = { workspace = true, features = ["serde"] }
-gimli = "0.28.1"
-graph-cycles = "0.1.0"
-hashbrown = "0.13.1"
-hex = { version = "0.4", optional = true }
-im = "15.0"
-indexmap = "2.0.0"
-itertools = "0.10"
-lazy_static = "1.4"
-miden-core = "0.3.0"
-object = { version = "0.32.2", features = ["write"] }
-parking_lot = "0.12"
-pest = "2.1.3"
-pest_derive = "2.1"
-petgraph = "0.6"
-rustc-hash = "1.1.0"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.91"
-sha2 = "0.9"
-strum = { version = "0.24.1", features = ["derive"] }
-sway-ast = { version = "0.60.0", path = "../sway-ast" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-ir = { version = "0.60.0", path = "../sway-ir" }
-sway-parse = { version = "0.60.0", path = "../sway-parse" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-thiserror = "1.0"
-tracing = "0.1"
-uint = "0.9"
-vec1 = "1.8.0"
+gimli.workspace = true
+graph-cycles.workspace = true
+hashbrown.workspace = true
+hex = { workspace = true, optional = true }
+im.workspace = true
+indexmap.workspace = true
+itertools.workspace = true
+lazy_static.workspace = true
+object = { workspace = true, features = ["write"] }
+parking_lot.workspace = true
+pest.workspace = true
+pest_derive.workspace = true
+petgraph.workspace = true
+rustc-hash.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+sha2.workspace = true
+strum = { workspace = true, features = ["derive"] }
+sway-ast.workspace = true
+sway-error.workspace = true
+sway-ir.workspace = true
+sway-parse.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+thiserror.workspace = true
+tracing.workspace = true
+uint.workspace = true
+vec1.workspace = true
 
 [target.'cfg(not(target_os = "macos"))'.dependencies]
 sysinfo = "0.29.0"
diff --git a/sway-core/src/abi_generation/abi_str.rs b/sway-core/src/abi_generation/abi_str.rs
index 3c94fc3a731..254b8a805ad 100644
--- a/sway-core/src/abi_generation/abi_str.rs
+++ b/sway-core/src/abi_generation/abi_str.rs
@@ -2,10 +2,12 @@ use sway_types::integer_bits::IntegerBits;
 
 use crate::{language::CallPath, Engines, TypeArgument, TypeId, TypeInfo};
 
+#[derive(Clone)]
 pub struct AbiStrContext {
-    pub program_name: Option<String>,
+    pub program_name: String,
     pub abi_with_callpaths: bool,
     pub abi_with_fully_specified_types: bool,
+    pub abi_root_type_without_generic_type_parameters: bool,
 }
 
 impl TypeId {
@@ -17,29 +19,28 @@ impl TypeId {
         resolved_type_id: TypeId,
     ) -> String {
         let type_engine = engines.te();
+        let self_abi_str = type_engine.get(*self).abi_str(ctx, engines, true);
         if self.is_generic_parameter(engines, resolved_type_id) {
-            format!("generic {}", type_engine.get(*self).abi_str(ctx, engines))
+            format!("generic {}", self_abi_str)
         } else {
             match (
                 &*type_engine.get(*self),
                 &*type_engine.get(resolved_type_id),
             ) {
-                (TypeInfo::Custom { .. }, TypeInfo::Struct { .. }) => {
-                    type_engine.get(resolved_type_id).abi_str(ctx, engines)
-                }
-                (TypeInfo::Custom { .. }, TypeInfo::Enum { .. }) => {
-                    type_engine.get(resolved_type_id).abi_str(ctx, engines)
-                }
-                (TypeInfo::Custom { .. }, TypeInfo::Alias { .. }) => {
-                    type_engine.get(resolved_type_id).abi_str(ctx, engines)
+                (TypeInfo::Custom { .. }, TypeInfo::Struct { .. })
+                | (TypeInfo::Custom { .. }, TypeInfo::Enum { .. }) => type_engine
+                    .get(resolved_type_id)
+                    .abi_str(ctx, engines, true),
+                (_, TypeInfo::Alias { ty, .. }) => {
+                    ty.type_id.get_abi_type_str(ctx, engines, ty.type_id)
                 }
                 (TypeInfo::Tuple(fields), TypeInfo::Tuple(resolved_fields)) => {
                     assert_eq!(fields.len(), resolved_fields.len());
-                    let field_strs = fields
+                    let field_strs = resolved_fields
                         .iter()
                         .map(|f| {
                             if ctx.abi_with_fully_specified_types {
-                                type_engine.get(f.type_id).abi_str(ctx, engines)
+                                type_engine.get(f.type_id).abi_str(ctx, engines, false)
                             } else {
                                 "_".to_string()
                             }
@@ -47,26 +48,40 @@ impl TypeId {
                         .collect::<Vec<String>>();
                     format!("({})", field_strs.join(", "))
                 }
-                (TypeInfo::Array(type_arg, count), TypeInfo::Array(_, resolved_count)) => {
+                (TypeInfo::Array(_, count), TypeInfo::Array(type_arg, resolved_count)) => {
                     assert_eq!(count.val(), resolved_count.val());
                     let inner_type = if ctx.abi_with_fully_specified_types {
-                        type_engine.get(type_arg.type_id).abi_str(ctx, engines)
+                        type_engine
+                            .get(type_arg.type_id)
+                            .abi_str(ctx, engines, false)
                     } else {
                         "_".to_string()
                     };
                     format!("[{}; {}]", inner_type, count.val())
                 }
+                (TypeInfo::Slice(type_arg), TypeInfo::Slice(_)) => {
+                    let inner_type = if ctx.abi_with_fully_specified_types {
+                        type_engine
+                            .get(type_arg.type_id)
+                            .abi_str(ctx, engines, false)
+                    } else {
+                        "_".to_string()
+                    };
+                    format!("[{}]", inner_type)
+                }
                 (TypeInfo::Custom { .. }, _) => {
-                    format!("generic {}", type_engine.get(*self).abi_str(ctx, engines))
+                    format!("generic {}", self_abi_str)
                 }
-                _ => type_engine.get(resolved_type_id).abi_str(ctx, engines),
+                _ => type_engine
+                    .get(resolved_type_id)
+                    .abi_str(ctx, engines, true),
             }
         }
     }
 }
 
 impl TypeInfo {
-    pub fn abi_str(&self, ctx: &AbiStrContext, engines: &Engines) -> String {
+    pub fn abi_str(&self, ctx: &AbiStrContext, engines: &Engines, is_root: bool) -> String {
         use TypeInfo::*;
         let decl_engine = engines.de();
         let type_engine = engines.te();
@@ -94,7 +109,7 @@ impl TypeInfo {
             Tuple(fields) => {
                 let field_strs = fields
                     .iter()
-                    .map(|field| field.abi_str(ctx, engines))
+                    .map(|field| field.abi_str(ctx, engines, false))
                     .collect::<Vec<String>>();
                 format!("({})", field_strs.join(", "))
             }
@@ -102,21 +117,30 @@ impl TypeInfo {
             Numeric => "u64".into(), // u64 is the default
             Contract => "contract".into(),
             ErrorRecovery(_) => "unknown due to error".into(),
+            UntypedEnum(decl_id) => {
+                let decl = engines.pe().get_enum(decl_id);
+                format!("untyped enum {}", decl.name)
+            }
+            UntypedStruct(decl_id) => {
+                let decl = engines.pe().get_struct(decl_id);
+                format!("untyped struct {}", decl.name)
+            }
             Enum(decl_ref) => {
                 let decl = decl_engine.get_enum(decl_ref);
-                let type_params =
-                    if !ctx.abi_with_fully_specified_types || decl.type_parameters.is_empty() {
-                        "".into()
-                    } else {
-                        format!(
-                            "<{}>",
-                            decl.type_parameters
-                                .iter()
-                                .map(|p| type_engine.get(p.type_id).abi_str(ctx, engines))
-                                .collect::<Vec<_>>()
-                                .join(",")
-                        )
-                    };
+                let type_params = if (ctx.abi_root_type_without_generic_type_parameters && is_root)
+                    || decl.type_parameters.is_empty()
+                {
+                    "".into()
+                } else {
+                    format!(
+                        "<{}>",
+                        decl.type_parameters
+                            .iter()
+                            .map(|p| type_engine.get(p.type_id).abi_str(ctx, engines, false))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                };
                 format!(
                     "enum {}{}",
                     call_path_display(ctx, &decl.call_path),
@@ -125,19 +149,20 @@ impl TypeInfo {
             }
             Struct(decl_ref) => {
                 let decl = decl_engine.get_struct(decl_ref);
-                let type_params =
-                    if !ctx.abi_with_fully_specified_types || decl.type_parameters.is_empty() {
-                        "".into()
-                    } else {
-                        format!(
-                            "<{}>",
-                            decl.type_parameters
-                                .iter()
-                                .map(|p| type_engine.get(p.type_id).abi_str(ctx, engines))
-                                .collect::<Vec<_>>()
-                                .join(",")
-                        )
-                    };
+                let type_params = if (ctx.abi_root_type_without_generic_type_parameters && is_root)
+                    || decl.type_parameters.is_empty()
+                {
+                    "".into()
+                } else {
+                    format!(
+                        "<{}>",
+                        decl.type_parameters
+                            .iter()
+                            .map(|p| type_engine.get(p.type_id).abi_str(ctx, engines, false))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                };
                 format!(
                     "struct {}{}",
                     call_path_display(ctx, &decl.call_path),
@@ -148,18 +173,22 @@ impl TypeInfo {
                 format!("contract caller {abi_name}")
             }
             Array(elem_ty, length) => {
-                format!("[{}; {}]", elem_ty.abi_str(ctx, engines), length.val())
+                format!(
+                    "[{}; {}]",
+                    elem_ty.abi_str(ctx, engines, false),
+                    length.val()
+                )
             }
             Storage { .. } => "contract storage".into(),
             RawUntypedPtr => "raw untyped ptr".into(),
             RawUntypedSlice => "raw untyped slice".into(),
             Ptr(ty) => {
-                format!("__ptr {}", ty.abi_str(ctx, engines))
+                format!("__ptr {}", ty.abi_str(ctx, engines, false))
             }
             Slice(ty) => {
-                format!("__slice {}", ty.abi_str(ctx, engines))
+                format!("__slice {}", ty.abi_str(ctx, engines, false))
             }
-            Alias { ty, .. } => ty.abi_str(ctx, engines),
+            Alias { ty, .. } => ty.abi_str(ctx, engines, false),
             TraitType {
                 name,
                 trait_type_id: _,
@@ -171,7 +200,7 @@ impl TypeInfo {
                 format!(
                     "__ref {}{}", // TODO-IG: No references in ABIs according to the RFC. Or we want to have them?
                     if *to_mutable_value { "mut " } else { "" },
-                    referenced_type.abi_str(ctx, engines)
+                    referenced_type.abi_str(ctx, engines, false)
                 )
             }
         }
@@ -186,18 +215,11 @@ fn call_path_display(ctx: &AbiStrContext, call_path: &CallPath) -> String {
     }
     let mut buf = String::new();
     for (index, prefix) in call_path.prefixes.iter().enumerate() {
-        let mut skip_prefix = false;
-        if index == 0 {
-            if let Some(root_name) = &ctx.program_name {
-                if prefix.as_str() == root_name.as_str() {
-                    skip_prefix = true;
-                }
-            }
-        }
-        if !skip_prefix {
-            buf.push_str(prefix.as_str());
-            buf.push_str("::");
+        if index == 0 && prefix.as_str() == ctx.program_name {
+            continue;
         }
+        buf.push_str(prefix.as_str());
+        buf.push_str("::");
     }
     buf.push_str(&call_path.suffix.to_string());
 
@@ -205,7 +227,10 @@ fn call_path_display(ctx: &AbiStrContext, call_path: &CallPath) -> String {
 }
 
 impl TypeArgument {
-    pub(self) fn abi_str(&self, ctx: &AbiStrContext, engines: &Engines) -> String {
-        engines.te().get(self.type_id).abi_str(ctx, engines)
+    pub(self) fn abi_str(&self, ctx: &AbiStrContext, engines: &Engines, is_root: bool) -> String {
+        engines
+            .te()
+            .get(self.type_id)
+            .abi_str(ctx, engines, is_root)
     }
 }
diff --git a/sway-core/src/abi_generation/evm_abi.rs b/sway-core/src/abi_generation/evm_abi.rs
index 6cfb1040484..f723f36d14a 100644
--- a/sway-core/src/abi_generation/evm_abi.rs
+++ b/sway-core/src/abi_generation/evm_abi.rs
@@ -49,6 +49,7 @@ fn get_type_str(type_id: &TypeId, engines: &Engines, resolved_type_id: TypeId) -
                 assert_eq!(count.val(), resolved_count.val());
                 format!("[_; {}]", count.val())
             }
+            (TypeInfo::Slice(_), TypeInfo::Slice(_)) => "__slice[_]".into(),
             (TypeInfo::Custom { .. }, _) => {
                 format!("generic {}", abi_str(&type_engine.get(*type_id), engines))
             }
@@ -92,6 +93,14 @@ pub fn abi_str(type_info: &TypeInfo, engines: &Engines) -> String {
         Numeric => "u64".into(), // u64 is the default
         Contract => "contract".into(),
         ErrorRecovery(_) => "unknown due to error".into(),
+        UntypedEnum(decl_id) => {
+            let decl = engines.pe().get_enum(decl_id);
+            format!("untyped enum {}", decl.name)
+        }
+        UntypedStruct(decl_id) => {
+            let decl = engines.pe().get_struct(decl_id);
+            format!("untyped struct {}", decl.name)
+        }
         Enum(decl_ref) => {
             let decl = decl_engine.get_enum(decl_ref);
             format!("enum {}", decl.call_path.suffix)
diff --git a/sway-core/src/abi_generation/fuel_abi.rs b/sway-core/src/abi_generation/fuel_abi.rs
index 1479dd2c155..7fdd704155d 100644
--- a/sway-core/src/abi_generation/fuel_abi.rs
+++ b/sway-core/src/abi_generation/fuel_abi.rs
@@ -1,5 +1,10 @@
-use fuel_abi_types::abi::program as program_abi;
-use std::collections::HashSet;
+use fuel_abi_types::abi::program::{
+    self as program_abi, ConcreteTypeId, MetadataTypeId, TypeConcreteDeclaration,
+};
+use sha2::{Digest, Sha256};
+use std::collections::{HashMap, HashSet};
+use sway_error::handler::{ErrorEmitted, Handler};
+use sway_types::Span;
 
 use crate::{
     language::ty::{TyFunctionDecl, TyProgram, TyProgramKind},
@@ -12,395 +17,799 @@ use super::abi_str::AbiStrContext;
 pub struct AbiContext<'a> {
     pub program: &'a TyProgram,
     pub abi_with_callpaths: bool,
+    pub type_ids_to_full_type_str: HashMap<String, String>,
 }
 
 impl<'a> AbiContext<'a> {
-    fn to_str_context(
-        &self,
-        engines: &Engines,
-        abi_with_fully_specified_types: bool,
-    ) -> AbiStrContext {
+    fn to_str_context(&self, engines: &Engines, abi_full: bool) -> AbiStrContext {
         AbiStrContext {
             program_name: self
                 .program
                 .root
                 .namespace
                 .program_id(engines)
-                .read(engines, |m| m.name.clone().map(|v| v.as_str().to_string())),
+                .read(engines, |m| m.name().to_string()),
             abi_with_callpaths: self.abi_with_callpaths,
-            abi_with_fully_specified_types,
+            abi_with_fully_specified_types: abi_full,
+            abi_root_type_without_generic_type_parameters: !abi_full,
         }
     }
 }
 
+impl TypeId {
+    fn get_abi_type_field_and_concrete_id(
+        &self,
+        handler: &Handler,
+        ctx: &mut AbiContext,
+        engines: &Engines,
+        resolved_type_id: TypeId,
+    ) -> Result<(String, ConcreteTypeId), ErrorEmitted> {
+        let type_str = self.get_abi_type_str(
+            &AbiStrContext {
+                program_name: ctx
+                    .program
+                    .root
+                    .namespace
+                    .program_id(engines)
+                    .read(engines, |m| m.name().clone().as_str().to_string()),
+                abi_with_callpaths: true,
+                abi_with_fully_specified_types: true,
+                abi_root_type_without_generic_type_parameters: false,
+            },
+            engines,
+            resolved_type_id,
+        );
+        let mut hasher = Sha256::new();
+        hasher.update(type_str.clone());
+        let result = hasher.finalize();
+        let type_id = format!("{:x}", result);
+
+        if let Some(old_type_str) = ctx
+            .type_ids_to_full_type_str
+            .insert(type_id.clone(), type_str.clone())
+        {
+            if old_type_str != type_str {
+                return Err(
+                    handler.emit_err(sway_error::error::CompileError::ABIHashCollision {
+                        span: Span::dummy(),
+                        hash: type_id,
+                        first_type: old_type_str,
+                        second_type: type_str,
+                    }),
+                );
+            }
+        }
+
+        Ok((type_str, ConcreteTypeId(type_id)))
+    }
+}
+
 pub fn generate_program_abi(
+    handler: &Handler,
     ctx: &mut AbiContext,
     engines: &Engines,
-    types: &mut Vec<program_abi::TypeDeclaration>,
-    encoding: Option<program_abi::Version>,
-) -> program_abi::ProgramABI {
+    encoding_version: program_abi::Version,
+    spec_version: program_abi::Version,
+) -> Result<program_abi::ProgramABI, ErrorEmitted> {
     let decl_engine = engines.de();
-    match &ctx.program.kind {
+    let metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration> = &mut vec![];
+    let concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration> = &mut vec![];
+    let mut program_abi = match &ctx.program.kind {
         TyProgramKind::Contract { abi_entries, .. } => {
             let functions = abi_entries
                 .iter()
                 .map(|x| {
                     let fn_decl = decl_engine.get_function(x);
-                    fn_decl.generate_abi_function(ctx, engines, types)
+                    fn_decl.generate_abi_function(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                    )
                 })
-                .collect();
-            let logged_types = generate_logged_types(ctx, engines, types);
-            let messages_types = generate_messages_types(ctx, engines, types);
-            let configurables = generate_configurables(ctx, engines, types);
+                .collect::<Result<Vec<_>, _>>()?;
+            let logged_types =
+                generate_logged_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let messages_types =
+                generate_messages_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let configurables =
+                generate_configurables(handler, ctx, engines, metadata_types, concrete_types)?;
+            program_abi::ProgramABI {
+                program_type: "contract".to_string(),
+                spec_version,
+                encoding_version,
+                metadata_types: metadata_types.to_vec(),
+                concrete_types: concrete_types.to_vec(),
+                functions,
+                logged_types: Some(logged_types),
+                messages_types: Some(messages_types),
+                configurables: Some(configurables),
+            }
+        }
+        TyProgramKind::Script { main_function, .. } => {
+            let main_function = decl_engine.get_function(main_function);
+            let functions = vec![main_function.generate_abi_function(
+                handler,
+                ctx,
+                engines,
+                metadata_types,
+                concrete_types,
+            )?];
+            let logged_types =
+                generate_logged_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let messages_types =
+                generate_messages_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let configurables =
+                generate_configurables(handler, ctx, engines, metadata_types, concrete_types)?;
             program_abi::ProgramABI {
-                encoding,
-                types: types.to_vec(),
+                program_type: "script".to_string(),
+                spec_version,
+                encoding_version,
+                metadata_types: metadata_types.to_vec(),
+                concrete_types: concrete_types.to_vec(),
                 functions,
                 logged_types: Some(logged_types),
                 messages_types: Some(messages_types),
                 configurables: Some(configurables),
             }
         }
-        TyProgramKind::Script { main_function, .. }
-        | TyProgramKind::Predicate { main_function, .. } => {
+        TyProgramKind::Predicate { main_function, .. } => {
             let main_function = decl_engine.get_function(main_function);
-            let functions = vec![main_function.generate_abi_function(ctx, engines, types)];
-            let logged_types = generate_logged_types(ctx, engines, types);
-            let messages_types = generate_messages_types(ctx, engines, types);
-            let configurables = generate_configurables(ctx, engines, types);
+            let functions = vec![main_function.generate_abi_function(
+                handler,
+                ctx,
+                engines,
+                metadata_types,
+                concrete_types,
+            )?];
+            let logged_types =
+                generate_logged_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let messages_types =
+                generate_messages_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let configurables =
+                generate_configurables(handler, ctx, engines, metadata_types, concrete_types)?;
             program_abi::ProgramABI {
-                encoding,
-                types: types.to_vec(),
+                program_type: "predicate".to_string(),
+                spec_version,
+                encoding_version,
+                metadata_types: metadata_types.to_vec(),
+                concrete_types: concrete_types.to_vec(),
                 functions,
                 logged_types: Some(logged_types),
                 messages_types: Some(messages_types),
                 configurables: Some(configurables),
             }
         }
-        _ => program_abi::ProgramABI {
-            encoding,
-            types: vec![],
-            functions: vec![],
-            logged_types: None,
-            messages_types: None,
-            configurables: None,
-        },
+        TyProgramKind::Library { .. } => {
+            let logged_types =
+                generate_logged_types(handler, ctx, engines, metadata_types, concrete_types)?;
+            let messages_types =
+                generate_messages_types(handler, ctx, engines, metadata_types, concrete_types)?;
+
+            program_abi::ProgramABI {
+                program_type: "library".to_string(),
+                spec_version,
+                encoding_version,
+                metadata_types: metadata_types.to_vec(),
+                concrete_types: concrete_types.to_vec(),
+                functions: vec![],
+                logged_types: Some(logged_types),
+                messages_types: Some(messages_types),
+                configurables: None,
+            }
+        }
+    };
+
+    standardize_json_abi_types(&mut program_abi);
+
+    Ok(program_abi)
+}
+
+/// Standardize the JSON ABI data structure by eliminating duplicate types. This is an iterative
+/// process because every time two types are merged, new opportunities for more merging arise.
+fn standardize_json_abi_types(json_abi_program: &mut program_abi::ProgramABI) {
+    // Dedup TypeMetadataDeclaration
+    loop {
+        // If type with id_1 is a duplicate of type with id_2, then keep track of the mapping
+        // between id_1 and id_2 in the HashMap below.
+        let mut old_to_new_id: HashMap<MetadataTypeId, program_abi::TypeId> = HashMap::new();
+
+        // A vector containing unique `program_abi::TypeMetadataDeclaration`s.
+        //
+        // Two `program_abi::TypeMetadataDeclaration` are deemed the same if the have the same
+        // `type_field`, `components`, and `type_parameters` (even if their `type_id`s are
+        // different).
+        let mut deduped_types: Vec<program_abi::TypeMetadataDeclaration> = Vec::new();
+
+        // Insert values in `deduped_types` if they haven't been inserted before. Otherwise, create
+        // an appropriate mapping between type IDs in the HashMap `old_to_new_id`.
+        for decl in &json_abi_program.metadata_types {
+            // First replace metadata_type_id with concrete_type_id when possible
+            if let Some(ty) = json_abi_program.concrete_types.iter().find(|d| {
+                d.type_field == decl.type_field
+                    && decl.components.is_none()
+                    && decl.type_parameters.is_none()
+            }) {
+                old_to_new_id.insert(
+                    decl.metadata_type_id.clone(),
+                    program_abi::TypeId::Concrete(ty.concrete_type_id.clone()),
+                );
+            } else {
+                // Second replace metadata_type_id with metadata_type_id when possible
+                if let Some(ty) = deduped_types.iter().find(|d| {
+                    d.type_field == decl.type_field
+                        && d.components == decl.components
+                        && d.type_parameters == decl.type_parameters
+                }) {
+                    old_to_new_id.insert(
+                        decl.metadata_type_id.clone(),
+                        program_abi::TypeId::Metadata(ty.metadata_type_id.clone()),
+                    );
+                } else {
+                    deduped_types.push(decl.clone());
+                }
+            }
+        }
+
+        // Nothing to do if the hash map is empty as there are not merge opportunities. We can now
+        // exit the loop.
+        if old_to_new_id.is_empty() {
+            break;
+        }
+
+        json_abi_program.metadata_types = deduped_types;
+
+        update_all_types(json_abi_program, &old_to_new_id);
+    }
+
+    // Dedup TypeConcreteDeclaration
+    let mut concrete_declarations_map: HashMap<ConcreteTypeId, TypeConcreteDeclaration> =
+        HashMap::new();
+    for decl in &json_abi_program.concrete_types {
+        concrete_declarations_map.insert(decl.concrete_type_id.clone(), decl.clone());
     }
+    json_abi_program.concrete_types = concrete_declarations_map.values().cloned().collect();
+
+    // Sort the `program_abi::TypeMetadataDeclaration`s
+    json_abi_program
+        .metadata_types
+        .sort_by(|t1, t2| t1.type_field.cmp(&t2.type_field));
+
+    // Sort the `program_abi::TypeConcreteDeclaration`s
+    json_abi_program
+        .concrete_types
+        .sort_by(|t1, t2| t1.type_field.cmp(&t2.type_field));
+
+    // Standardize IDs (i.e. change them to 0,1,2,... according to the alphabetical order above
+    let mut old_to_new_id: HashMap<MetadataTypeId, program_abi::TypeId> = HashMap::new();
+    for (ix, decl) in json_abi_program.metadata_types.iter_mut().enumerate() {
+        old_to_new_id.insert(
+            decl.metadata_type_id.clone(),
+            program_abi::TypeId::Metadata(MetadataTypeId(ix)),
+        );
+        decl.metadata_type_id = MetadataTypeId(ix);
+    }
+
+    update_all_types(json_abi_program, &old_to_new_id);
 }
 
-fn generate_logged_types(
+/// Recursively updates the type IDs used in a program_abi::ProgramABI
+fn update_all_types(
+    json_abi_program: &mut program_abi::ProgramABI,
+    old_to_new_id: &HashMap<MetadataTypeId, program_abi::TypeId>,
+) {
+    // Update all `program_abi::TypeMetadataDeclaration`
+    for decl in &mut json_abi_program.metadata_types {
+        update_json_type_metadata_declaration(decl, old_to_new_id);
+    }
+
+    // Update all `program_abi::TypeConcreteDeclaration`
+    for decl in &mut json_abi_program.concrete_types {
+        update_json_type_concrete_declaration(decl, old_to_new_id);
+    }
+}
+
+/// Recursively updates the type IDs used in a `program_abi::TypeApplication` given a HashMap from
+/// old to new IDs
+fn update_json_type_application(
+    type_application: &mut program_abi::TypeApplication,
+    old_to_new_id: &HashMap<MetadataTypeId, program_abi::TypeId>,
+) {
+    if let fuel_abi_types::abi::program::TypeId::Metadata(metadata_type_id) =
+        &type_application.type_id
+    {
+        if let Some(new_id) = old_to_new_id.get(metadata_type_id) {
+            type_application.type_id = new_id.clone();
+        }
+    }
+
+    if let Some(args) = &mut type_application.type_arguments {
+        for arg in args.iter_mut() {
+            update_json_type_application(arg, old_to_new_id);
+        }
+    }
+}
+
+/// Recursively updates the metadata type IDs used in a `program_abi::TypeMetadataDeclaration` given a HashMap from
+/// old to new IDs
+fn update_json_type_metadata_declaration(
+    type_declaration: &mut program_abi::TypeMetadataDeclaration,
+    old_to_new_id: &HashMap<MetadataTypeId, program_abi::TypeId>,
+) {
+    if let Some(params) = &mut type_declaration.type_parameters {
+        for param in params.iter_mut() {
+            if let Some(fuel_abi_types::abi::program::TypeId::Metadata(new_id)) =
+                old_to_new_id.get(param)
+            {
+                *param = new_id.clone();
+            }
+        }
+    }
+
+    if let Some(components) = &mut type_declaration.components {
+        for component in components.iter_mut() {
+            update_json_type_application(component, old_to_new_id);
+        }
+    }
+}
+
+/// RUpdates the metadata type IDs used in a `program_abi::TypeConcreteDeclaration` given a HashMap from
+/// old to new IDs
+fn update_json_type_concrete_declaration(
+    type_declaration: &mut program_abi::TypeConcreteDeclaration,
+    old_to_new_id: &HashMap<MetadataTypeId, program_abi::TypeId>,
+) {
+    if let Some(metadata_type_id) = &mut type_declaration.metadata_type_id {
+        if let Some(fuel_abi_types::abi::program::TypeId::Metadata(new_id)) =
+            old_to_new_id.get(metadata_type_id)
+        {
+            *metadata_type_id = new_id.clone();
+        }
+    }
+}
+
+fn generate_concrete_type_declaration(
+    handler: &Handler,
     ctx: &mut AbiContext,
     engines: &Engines,
-    types: &mut Vec<program_abi::TypeDeclaration>,
-) -> Vec<program_abi::LoggedType> {
-    // A list of all `program_abi::TypeDeclaration`s needed for the logged types
-    let logged_types = ctx
-        .program
-        .logged_types
-        .iter()
-        .map(|(_, type_id)| program_abi::TypeDeclaration {
-            type_id: type_id.index(),
-            type_field: type_id.get_abi_type_str(
-                &ctx.to_str_context(engines, false),
-                engines,
-                *type_id,
-            ),
-            components: type_id.get_abi_type_components(ctx, engines, types, *type_id),
-            type_parameters: type_id.get_abi_type_parameters(ctx, engines, types, *type_id),
-        })
-        .collect::<Vec<_>>();
+    metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+    type_id: TypeId,
+    resolved_type_id: TypeId,
+) -> Result<ConcreteTypeId, ErrorEmitted> {
+    let mut new_metadata_types_to_add = Vec::<program_abi::TypeMetadataDeclaration>::new();
+    let type_metadata_decl = program_abi::TypeMetadataDeclaration {
+        metadata_type_id: MetadataTypeId(type_id.index()),
+        type_field: type_id.get_abi_type_str(
+            &ctx.to_str_context(engines, false),
+            engines,
+            resolved_type_id,
+        ),
+        components: type_id.get_abi_type_components(
+            handler,
+            ctx,
+            engines,
+            metadata_types,
+            concrete_types,
+            resolved_type_id,
+            &mut new_metadata_types_to_add,
+        )?,
+        type_parameters: type_id.get_abi_type_parameters(
+            handler,
+            ctx,
+            engines,
+            metadata_types,
+            concrete_types,
+            resolved_type_id,
+            &mut new_metadata_types_to_add,
+        )?,
+    };
+
+    let metadata_type_id = if type_metadata_decl.type_parameters.is_some()
+        || type_metadata_decl.components.is_some()
+    {
+        Some(type_metadata_decl.metadata_type_id.clone())
+    } else {
+        None
+    };
+    let type_arguments = if type_metadata_decl.type_parameters.is_some() {
+        type_id.get_abi_type_arguments_as_concrete_type_ids(
+            handler,
+            ctx,
+            engines,
+            metadata_types,
+            concrete_types,
+            resolved_type_id,
+        )?
+    } else {
+        None
+    };
+
+    metadata_types.push(type_metadata_decl);
+    metadata_types.extend(new_metadata_types_to_add);
+
+    let (type_field, concrete_type_id) =
+        type_id.get_abi_type_field_and_concrete_id(handler, ctx, engines, resolved_type_id)?;
+    let concrete_type_decl = TypeConcreteDeclaration {
+        type_field,
+        concrete_type_id: concrete_type_id.clone(),
+        metadata_type_id,
+        type_arguments,
+    };
+
+    concrete_types.push(concrete_type_decl);
 
-    // Add the new types to `types`
-    types.extend(logged_types);
+    Ok(concrete_type_id)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn generate_type_metadata_declaration(
+    handler: &Handler,
+    ctx: &mut AbiContext,
+    engines: &Engines,
+    metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+    type_id: TypeId,
+    resolved_type_id: TypeId,
+    metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
+) -> Result<(), ErrorEmitted> {
+    let mut new_metadata_types_to_add = Vec::<program_abi::TypeMetadataDeclaration>::new();
+    let components = type_id.get_abi_type_components(
+        handler,
+        ctx,
+        engines,
+        metadata_types,
+        concrete_types,
+        resolved_type_id,
+        &mut new_metadata_types_to_add,
+    )?;
+    let type_parameters = type_id.get_abi_type_parameters(
+        handler,
+        ctx,
+        engines,
+        metadata_types,
+        concrete_types,
+        resolved_type_id,
+        &mut new_metadata_types_to_add,
+    )?;
+    let type_metadata_decl = program_abi::TypeMetadataDeclaration {
+        metadata_type_id: MetadataTypeId(type_id.index()),
+        type_field: type_id.get_abi_type_str(
+            &ctx.to_str_context(engines, false),
+            engines,
+            resolved_type_id,
+        ),
+        components,
+        type_parameters,
+    };
+
+    metadata_types_to_add.push(type_metadata_decl.clone());
+    metadata_types_to_add.extend(new_metadata_types_to_add);
+
+    Ok(())
+}
 
+fn generate_logged_types(
+    handler: &Handler,
+    ctx: &mut AbiContext,
+    engines: &Engines,
+    metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+) -> Result<Vec<program_abi::LoggedType>, ErrorEmitted> {
     // Generate the JSON data for the logged types
     let mut log_ids: HashSet<u64> = HashSet::default();
-    ctx.program
+    Ok(ctx
+        .program
         .logged_types
         .iter()
-        .filter_map(|(log_id, type_id)| {
+        .map(|(log_id, type_id)| {
             let log_id = log_id.hash_id;
             if log_ids.contains(&log_id) {
-                None
+                Ok(None)
             } else {
                 log_ids.insert(log_id);
-                Some(program_abi::LoggedType {
+                Ok(Some(program_abi::LoggedType {
                     log_id: log_id.to_string(),
-                    application: program_abi::TypeApplication {
-                        name: "".to_string(),
-                        type_id: type_id.index(),
-                        type_arguments: type_id
-                            .get_abi_type_arguments(ctx, engines, types, *type_id),
-                    },
-                })
+                    concrete_type_id: generate_concrete_type_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        *type_id,
+                        *type_id,
+                    )?,
+                }))
             }
         })
-        .collect()
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .flatten()
+        .collect())
 }
 
 fn generate_messages_types(
+    handler: &Handler,
     ctx: &mut AbiContext,
     engines: &Engines,
-    types: &mut Vec<program_abi::TypeDeclaration>,
-) -> Vec<program_abi::MessageType> {
-    // A list of all `program_abi::TypeDeclaration`s needed for the messages types
-    let messages_types = ctx
-        .program
-        .messages_types
-        .iter()
-        .map(|(_, type_id)| program_abi::TypeDeclaration {
-            type_id: type_id.index(),
-            type_field: type_id.get_abi_type_str(
-                &ctx.to_str_context(engines, false),
-                engines,
-                *type_id,
-            ),
-            components: type_id.get_abi_type_components(ctx, engines, types, *type_id),
-            type_parameters: type_id.get_abi_type_parameters(ctx, engines, types, *type_id),
-        })
-        .collect::<Vec<_>>();
-
-    // Add the new types to `types`
-    types.extend(messages_types);
-
+    metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+) -> Result<Vec<program_abi::MessageType>, ErrorEmitted> {
     // Generate the JSON data for the messages types
     ctx.program
         .messages_types
         .iter()
-        .map(|(message_id, type_id)| program_abi::MessageType {
-            message_id: **message_id as u64,
-            application: program_abi::TypeApplication {
-                name: "".to_string(),
-                type_id: type_id.index(),
-                type_arguments: type_id.get_abi_type_arguments(ctx, engines, types, *type_id),
-            },
+        .map(|(message_id, type_id)| {
+            Ok(program_abi::MessageType {
+                message_id: (**message_id as u64).to_string(),
+                concrete_type_id: generate_concrete_type_declaration(
+                    handler,
+                    ctx,
+                    engines,
+                    metadata_types,
+                    concrete_types,
+                    *type_id,
+                    *type_id,
+                )?,
+            })
         })
-        .collect()
+        .collect::<Result<Vec<_>, _>>()
 }
 
 fn generate_configurables(
+    handler: &Handler,
     ctx: &mut AbiContext,
     engines: &Engines,
-    types: &mut Vec<program_abi::TypeDeclaration>,
-) -> Vec<program_abi::Configurable> {
-    // A list of all `program_abi::TypeDeclaration`s needed for the configurables types
-    let configurables_types = ctx
-        .program
-        .configurables
-        .iter()
-        .map(|decl| program_abi::TypeDeclaration {
-            type_id: decl.type_ascription.type_id.index(),
-            type_field: decl.type_ascription.type_id.get_abi_type_str(
-                &ctx.to_str_context(engines, false),
-                engines,
-                decl.type_ascription.type_id,
-            ),
-            components: decl.type_ascription.type_id.get_abi_type_components(
-                ctx,
-                engines,
-                types,
-                decl.type_ascription.type_id,
-            ),
-            type_parameters: decl.type_ascription.type_id.get_abi_type_parameters(
-                ctx,
-                engines,
-                types,
-                decl.type_ascription.type_id,
-            ),
-        })
-        .collect::<Vec<_>>();
-
-    // Add the new types to `types`
-    types.extend(configurables_types);
-
+    metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+) -> Result<Vec<program_abi::Configurable>, ErrorEmitted> {
     // Generate the JSON data for the configurables types
     ctx.program
         .configurables
         .iter()
-        .map(|decl| program_abi::Configurable {
-            name: decl.call_path.suffix.to_string(),
-            application: program_abi::TypeApplication {
-                name: "".to_string(),
-                type_id: decl.type_ascription.type_id.index(),
-                type_arguments: decl.type_ascription.type_id.get_abi_type_arguments(
+        .map(|decl| {
+            Ok(program_abi::Configurable {
+                name: decl.call_path.suffix.to_string(),
+                concrete_type_id: generate_concrete_type_declaration(
+                    handler,
                     ctx,
                     engines,
-                    types,
+                    metadata_types,
+                    concrete_types,
                     decl.type_ascription.type_id,
-                ),
-            },
-            offset: 0,
+                    decl.type_ascription.type_id,
+                )?,
+                offset: 0,
+            })
         })
-        .collect()
+        .collect::<Result<Vec<_>, _>>()
 }
 
 impl TypeId {
     /// Return the type parameters of a given (potentially generic) type while considering what it
     /// actually resolves to. These parameters are essentially of type of `usize` which are
-    /// basically the IDs of some set of `program_abi::TypeDeclaration`s. The method below also
-    /// updates the provide list of `program_abi::TypeDeclaration`s  to add the newly discovered
+    /// basically the IDs of some set of `program_abi::TypeMetadataDeclaration`s. The method below also
+    /// updates the provide list of `program_abi::TypeMetadataDeclaration`s  to add the newly discovered
     /// types.
+    #[allow(clippy::too_many_arguments)]
     pub(self) fn get_abi_type_parameters(
         &self,
+        handler: &Handler,
         ctx: &mut AbiContext,
         engines: &Engines,
-        types: &mut Vec<program_abi::TypeDeclaration>,
+        metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+        concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
         resolved_type_id: TypeId,
-    ) -> Option<Vec<usize>> {
+        metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    ) -> Result<Option<Vec<MetadataTypeId>>, ErrorEmitted> {
         match self.is_generic_parameter(engines, resolved_type_id) {
-            true => None,
-            false => resolved_type_id.get_type_parameters(engines).map(|v| {
-                v.iter()
-                    .map(|v| v.get_abi_type_parameter(ctx, engines, types))
-                    .collect::<Vec<_>>()
-            }),
+            true => Ok(None),
+            false => resolved_type_id
+                .get_type_parameters(engines)
+                .map(|v| {
+                    v.iter()
+                        .map(|v| {
+                            v.get_abi_type_parameter(
+                                handler,
+                                ctx,
+                                engines,
+                                metadata_types,
+                                concrete_types,
+                                metadata_types_to_add,
+                            )
+                        })
+                        .collect::<Result<Vec<_>, _>>()
+                })
+                .map_or(Ok(None), |v| v.map(Some)),
         }
     }
+
     /// Return the components of a given (potentially generic) type while considering what it
     /// actually resolves to. These components are essentially of type of
     /// `program_abi::TypeApplication`.  The method below also updates the provided list of
-    /// `program_abi::TypeDeclaration`s  to add the newly discovered types.
+    /// `program_abi::TypeMetadataDeclaration`s  to add the newly discovered types.
+    #[allow(clippy::too_many_arguments)]
     pub(self) fn get_abi_type_components(
         &self,
+        handler: &Handler,
         ctx: &mut AbiContext,
         engines: &Engines,
-        types: &mut Vec<program_abi::TypeDeclaration>,
+        metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+        concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
         resolved_type_id: TypeId,
-    ) -> Option<Vec<program_abi::TypeApplication>> {
+        metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    ) -> Result<Option<Vec<program_abi::TypeApplication>>, ErrorEmitted> {
         let type_engine = engines.te();
         let decl_engine = engines.de();
-        match &*type_engine.get(*self) {
+        Ok(match &*type_engine.get(*self) {
             TypeInfo::Enum(decl_ref) => {
                 let decl = decl_engine.get_enum(decl_ref);
-                // A list of all `program_abi::TypeDeclaration`s needed for the enum variants
-                let variants = decl
-                    .variants
-                    .iter()
-                    .map(|x| program_abi::TypeDeclaration {
-                        type_id: x.type_argument.initial_type_id.index(),
-                        type_field: x.type_argument.initial_type_id.get_abi_type_str(
-                            &ctx.to_str_context(engines, false),
-                            engines,
-                            x.type_argument.type_id,
-                        ),
-                        components: x.type_argument.initial_type_id.get_abi_type_components(
-                            ctx,
-                            engines,
-                            types,
-                            x.type_argument.type_id,
-                        ),
-                        type_parameters: x.type_argument.initial_type_id.get_abi_type_parameters(
-                            ctx,
-                            engines,
-                            types,
-                            x.type_argument.type_id,
-                        ),
-                    })
-                    .collect::<Vec<_>>();
-                types.extend(variants);
+
+                let mut new_metadata_types_to_add =
+                    Vec::<program_abi::TypeMetadataDeclaration>::new();
+                for x in decl.variants.iter() {
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        x.type_argument.initial_type_id,
+                        x.type_argument.type_id,
+                        &mut new_metadata_types_to_add,
+                    )?;
+                }
 
                 // Generate the JSON data for the enum. This is basically a list of
                 // `program_abi::TypeApplication`s
-                Some(
-                    decl.variants
-                        .iter()
-                        .map(|x| program_abi::TypeApplication {
+                let components = decl
+                    .variants
+                    .iter()
+                    .map(|x| {
+                        Ok(program_abi::TypeApplication {
                             name: x.name.to_string(),
-                            type_id: x.type_argument.initial_type_id.index(),
-                            type_arguments: x.type_argument.initial_type_id.get_abi_type_arguments(
-                                ctx,
-                                engines,
-                                types,
-                                x.type_argument.type_id,
-                            ),
+                            type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                                x.type_argument.initial_type_id.index(),
+                            )),
+                            type_arguments: x
+                                .type_argument
+                                .initial_type_id
+                                .get_abi_type_arguments(
+                                    handler,
+                                    ctx,
+                                    engines,
+                                    metadata_types,
+                                    concrete_types,
+                                    x.type_argument.type_id,
+                                    &mut new_metadata_types_to_add,
+                                )?,
                         })
-                        .collect(),
-                )
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                if components.is_empty() {
+                    None
+                } else {
+                    metadata_types_to_add.extend(new_metadata_types_to_add);
+                    Some(components)
+                }
             }
             TypeInfo::Struct(decl_ref) => {
                 let decl = decl_engine.get_struct(decl_ref);
 
-                // A list of all `program_abi::TypeDeclaration`s needed for the struct fields
-                let field_types = decl
-                    .fields
-                    .iter()
-                    .map(|x| program_abi::TypeDeclaration {
-                        type_id: x.type_argument.initial_type_id.index(),
-                        type_field: x.type_argument.initial_type_id.get_abi_type_str(
-                            &ctx.to_str_context(engines, false),
-                            engines,
-                            x.type_argument.type_id,
-                        ),
-                        components: x.type_argument.initial_type_id.get_abi_type_components(
-                            ctx,
-                            engines,
-                            types,
-                            x.type_argument.type_id,
-                        ),
-                        type_parameters: x.type_argument.initial_type_id.get_abi_type_parameters(
-                            ctx,
-                            engines,
-                            types,
-                            x.type_argument.type_id,
-                        ),
-                    })
-                    .collect::<Vec<_>>();
-                types.extend(field_types);
+                let mut new_metadata_types_to_add =
+                    Vec::<program_abi::TypeMetadataDeclaration>::new();
+                for x in decl.fields.iter() {
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        x.type_argument.initial_type_id,
+                        x.type_argument.type_id,
+                        &mut new_metadata_types_to_add,
+                    )?;
+                }
 
                 // Generate the JSON data for the struct. This is basically a list of
                 // `program_abi::TypeApplication`s
-                Some(
-                    decl.fields
-                        .iter()
-                        .map(|x| program_abi::TypeApplication {
+                let components = decl
+                    .fields
+                    .iter()
+                    .map(|x| {
+                        Ok(program_abi::TypeApplication {
                             name: x.name.to_string(),
-                            type_id: x.type_argument.initial_type_id.index(),
-                            type_arguments: x.type_argument.initial_type_id.get_abi_type_arguments(
-                                ctx,
-                                engines,
-                                types,
-                                x.type_argument.type_id,
-                            ),
+                            type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                                x.type_argument.initial_type_id.index(),
+                            )),
+                            type_arguments: x
+                                .type_argument
+                                .initial_type_id
+                                .get_abi_type_arguments(
+                                    handler,
+                                    ctx,
+                                    engines,
+                                    metadata_types,
+                                    concrete_types,
+                                    x.type_argument.type_id,
+                                    &mut new_metadata_types_to_add,
+                                )?,
                         })
-                        .collect(),
-                )
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                if components.is_empty() {
+                    None
+                } else {
+                    metadata_types_to_add.extend(new_metadata_types_to_add);
+                    Some(components)
+                }
             }
             TypeInfo::Array(..) => {
                 if let TypeInfo::Array(elem_ty, _) = &*type_engine.get(resolved_type_id) {
-                    // The `program_abi::TypeDeclaration`s needed for the array element type
-                    let elem_abi_ty = program_abi::TypeDeclaration {
-                        type_id: elem_ty.initial_type_id.index(),
-                        type_field: elem_ty.initial_type_id.get_abi_type_str(
-                            &ctx.to_str_context(engines, false),
-                            engines,
-                            elem_ty.type_id,
-                        ),
-                        components: elem_ty.initial_type_id.get_abi_type_components(
-                            ctx,
-                            engines,
-                            types,
-                            elem_ty.type_id,
-                        ),
-                        type_parameters: elem_ty.initial_type_id.get_abi_type_parameters(
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        elem_ty.initial_type_id,
+                        elem_ty.type_id,
+                        metadata_types_to_add,
+                    )?;
+
+                    // Generate the JSON data for the array. This is basically a single
+                    // `program_abi::TypeApplication` for the array element type
+                    Some(vec![program_abi::TypeApplication {
+                        name: "__array_element".to_string(),
+                        type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                            elem_ty.initial_type_id.index(),
+                        )),
+                        type_arguments: elem_ty.initial_type_id.get_abi_type_arguments(
+                            handler,
                             ctx,
                             engines,
-                            types,
+                            metadata_types,
+                            concrete_types,
                             elem_ty.type_id,
-                        ),
-                    };
-                    types.push(elem_abi_ty);
+                            metadata_types_to_add,
+                        )?,
+                    }])
+                } else {
+                    unreachable!();
+                }
+            }
+            TypeInfo::Slice(..) => {
+                if let TypeInfo::Slice(elem_ty) = &*type_engine.get(resolved_type_id) {
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        elem_ty.initial_type_id,
+                        elem_ty.type_id,
+                        metadata_types_to_add,
+                    )?;
 
                     // Generate the JSON data for the array. This is basically a single
                     // `program_abi::TypeApplication` for the array element type
                     Some(vec![program_abi::TypeApplication {
-                        name: "__array_element".to_string(),
-                        type_id: elem_ty.initial_type_id.index(),
+                        name: "__slice_element".to_string(),
+                        type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                            elem_ty.initial_type_id.index(),
+                        )),
                         type_arguments: elem_ty.initial_type_id.get_abi_type_arguments(
+                            handler,
                             ctx,
                             engines,
-                            types,
+                            metadata_types,
+                            concrete_types,
                             elem_ty.type_id,
-                        ),
+                            metadata_types_to_add,
+                        )?,
                     }])
                 } else {
                     unreachable!();
@@ -408,84 +817,96 @@ impl TypeId {
             }
             TypeInfo::Tuple(_) => {
                 if let TypeInfo::Tuple(fields) = &*type_engine.get(resolved_type_id) {
-                    // A list of all `program_abi::TypeDeclaration`s needed for the tuple fields
-                    let fields_types = fields
-                        .iter()
-                        .map(|x| program_abi::TypeDeclaration {
-                            type_id: x.initial_type_id.index(),
-                            type_field: x.initial_type_id.get_abi_type_str(
-                                &ctx.to_str_context(engines, false),
-                                engines,
-                                x.type_id,
-                            ),
-                            components: x
-                                .initial_type_id
-                                .get_abi_type_components(ctx, engines, types, x.type_id),
-                            type_parameters: x
-                                .initial_type_id
-                                .get_abi_type_parameters(ctx, engines, types, x.type_id),
-                        })
-                        .collect::<Vec<_>>();
-
-                    types.extend(fields_types);
+                    let mut new_metadata_types_to_add =
+                        Vec::<program_abi::TypeMetadataDeclaration>::new();
+                    for x in fields.iter() {
+                        generate_type_metadata_declaration(
+                            handler,
+                            ctx,
+                            engines,
+                            metadata_types,
+                            concrete_types,
+                            x.initial_type_id,
+                            x.type_id,
+                            &mut new_metadata_types_to_add,
+                        )?;
+                    }
 
                     // Generate the JSON data for the tuple. This is basically a list of
                     // `program_abi::TypeApplication`s
-                    Some(
-                        fields
-                            .iter()
-                            .map(|x| program_abi::TypeApplication {
+                    let components = fields
+                        .iter()
+                        .map(|x| {
+                            Ok(program_abi::TypeApplication {
                                 name: "__tuple_element".to_string(),
-                                type_id: x.initial_type_id.index(),
-                                type_arguments: x
-                                    .initial_type_id
-                                    .get_abi_type_arguments(ctx, engines, types, x.type_id),
+                                type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                                    x.initial_type_id.index(),
+                                )),
+                                type_arguments: x.initial_type_id.get_abi_type_arguments(
+                                    handler,
+                                    ctx,
+                                    engines,
+                                    metadata_types,
+                                    concrete_types,
+                                    x.type_id,
+                                    metadata_types_to_add,
+                                )?,
                             })
-                            .collect(),
-                    )
+                        })
+                        .collect::<Result<Vec<_>, _>>()?;
+                    if components.is_empty() {
+                        None
+                    } else {
+                        metadata_types_to_add.extend(new_metadata_types_to_add);
+                        Some(components)
+                    }
                 } else {
                     unreachable!()
                 }
             }
             TypeInfo::Custom { type_arguments, .. } => {
                 if !self.is_generic_parameter(engines, resolved_type_id) {
-                    // A list of all `program_abi::TypeDeclaration`s needed for the type arguments
-                    let type_args = type_arguments
-                        .clone()
-                        .unwrap_or_default()
-                        .iter()
-                        .zip(
-                            resolved_type_id
-                                .get_type_parameters(engines)
-                                .unwrap_or_default()
-                                .iter(),
-                        )
-                        .map(|(v, p)| program_abi::TypeDeclaration {
-                            type_id: v.initial_type_id.index(),
-                            type_field: v.initial_type_id.get_abi_type_str(
-                                &ctx.to_str_context(engines, false),
-                                engines,
-                                p.type_id,
-                            ),
-                            components: v
-                                .initial_type_id
-                                .get_abi_type_components(ctx, engines, types, p.type_id),
-                            type_parameters: v
-                                .initial_type_id
-                                .get_abi_type_parameters(ctx, engines, types, p.type_id),
-                        })
-                        .collect::<Vec<_>>();
-                    types.extend(type_args);
-
-                    resolved_type_id.get_abi_type_components(ctx, engines, types, resolved_type_id)
+                    for (v, p) in type_arguments.clone().unwrap_or_default().iter().zip(
+                        resolved_type_id
+                            .get_type_parameters(engines)
+                            .unwrap_or_default()
+                            .iter(),
+                    ) {
+                        generate_type_metadata_declaration(
+                            handler,
+                            ctx,
+                            engines,
+                            metadata_types,
+                            concrete_types,
+                            v.initial_type_id,
+                            p.type_id,
+                            metadata_types_to_add,
+                        )?;
+                    }
+                    resolved_type_id.get_abi_type_components(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        resolved_type_id,
+                        metadata_types_to_add,
+                    )?
                 } else {
                     None
                 }
             }
             TypeInfo::Alias { .. } => {
                 if let TypeInfo::Alias { ty, .. } = &*type_engine.get(resolved_type_id) {
-                    ty.initial_type_id
-                        .get_abi_type_components(ctx, engines, types, ty.type_id)
+                    ty.initial_type_id.get_abi_type_components(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        ty.type_id,
+                        metadata_types_to_add,
+                    )?
                 } else {
                     None
                 }
@@ -495,239 +916,302 @@ impl TypeId {
                 if *self == resolved_type_id {
                     None
                 } else {
-                    resolved_type_id.get_abi_type_components(ctx, engines, types, resolved_type_id)
+                    resolved_type_id.get_abi_type_components(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        resolved_type_id,
+                        metadata_types_to_add,
+                    )?
                 }
             }
             _ => None,
-        }
+        })
     }
 
     /// Return the type arguments of a given (potentially generic) type while considering what it
     /// actually resolves to. These arguments are essentially of type of
     /// `program_abi::TypeApplication`. The method below also updates the provided list of
-    /// `program_abi::TypeDeclaration`s  to add the newly discovered types.
+    /// `program_abi::TypeMetadataDeclaration`s  to add the newly discovered types.
+    #[allow(clippy::too_many_arguments)]
     pub(self) fn get_abi_type_arguments(
         &self,
+        handler: &Handler,
         ctx: &mut AbiContext,
         engines: &Engines,
-        types: &mut Vec<program_abi::TypeDeclaration>,
+        metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+        concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
         resolved_type_id: TypeId,
-    ) -> Option<Vec<program_abi::TypeApplication>> {
+        metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    ) -> Result<Option<Vec<program_abi::TypeApplication>>, ErrorEmitted> {
         let type_engine = engines.te();
         let decl_engine = engines.de();
         let resolved_params = resolved_type_id.get_type_parameters(engines);
-        match &*type_engine.get(*self) {
+        Ok(match &*type_engine.get(*self) {
             TypeInfo::Custom {
                 type_arguments: Some(type_arguments),
                 ..
             } => (!type_arguments.is_empty()).then_some({
                 let resolved_params = resolved_params.unwrap_or_default();
-                let abi_type_arguments = type_arguments
-                    .iter()
-                    .zip(resolved_params.iter())
-                    .map(|(v, p)| program_abi::TypeDeclaration {
-                        type_id: v.initial_type_id.index(),
-                        type_field: v.initial_type_id.get_abi_type_str(
-                            &ctx.to_str_context(engines, false),
-                            engines,
-                            p.type_id,
-                        ),
-                        components: v
-                            .initial_type_id
-                            .get_abi_type_components(ctx, engines, types, p.type_id),
-                        type_parameters: v
-                            .initial_type_id
-                            .get_abi_type_parameters(ctx, engines, types, p.type_id),
-                    })
-                    .collect::<Vec<_>>();
-                types.extend(abi_type_arguments);
+
+                for (v, p) in type_arguments.iter().zip(resolved_params.iter()) {
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        v.type_id,
+                        p.type_id,
+                        metadata_types_to_add,
+                    )?;
+                }
 
                 type_arguments
                     .iter()
-                    .map(|arg| program_abi::TypeApplication {
-                        name: "".to_string(),
-                        type_id: arg.initial_type_id.index(),
-                        type_arguments: arg.initial_type_id.get_abi_type_arguments(
-                            ctx,
-                            engines,
-                            types,
-                            arg.type_id,
-                        ),
+                    .zip(resolved_params.iter())
+                    .map(|(arg, p)| {
+                        Ok(program_abi::TypeApplication {
+                            name: "".to_string(),
+                            type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                                arg.initial_type_id.index(),
+                            )),
+                            type_arguments: arg.initial_type_id.get_abi_type_arguments(
+                                handler,
+                                ctx,
+                                engines,
+                                metadata_types,
+                                concrete_types,
+                                p.type_id,
+                                metadata_types_to_add,
+                            )?,
+                        })
                     })
-                    .collect::<Vec<_>>()
+                    .collect::<Result<Vec<_>, _>>()?
             }),
             TypeInfo::Enum(decl_ref) => {
                 let decl = decl_engine.get_enum(decl_ref);
-                // Here, type_id for each type parameter should contain resolved types
-                let abi_type_arguments = decl
+
+                let mut new_metadata_types_to_add =
+                    Vec::<program_abi::TypeMetadataDeclaration>::new();
+                for v in decl.type_parameters.iter() {
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        v.type_id,
+                        v.type_id,
+                        &mut new_metadata_types_to_add,
+                    )?;
+                }
+
+                let type_arguments = decl
                     .type_parameters
                     .iter()
-                    .map(|v| program_abi::TypeDeclaration {
-                        type_id: v.type_id.index(),
-                        type_field: v.type_id.get_abi_type_str(
-                            &ctx.to_str_context(engines, false),
-                            engines,
-                            v.type_id,
-                        ),
-                        components: v
-                            .type_id
-                            .get_abi_type_components(ctx, engines, types, v.type_id),
-                        type_parameters: v
-                            .type_id
-                            .get_abi_type_parameters(ctx, engines, types, v.type_id),
-                    })
-                    .collect::<Vec<_>>();
-                types.extend(abi_type_arguments);
-
-                Some(
-                    decl.type_parameters
-                        .iter()
-                        .map(|arg| program_abi::TypeApplication {
+                    .map(|arg| {
+                        Ok(program_abi::TypeApplication {
                             name: "".to_string(),
-                            type_id: arg.type_id.index(),
+                            type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                                arg.type_id.index(),
+                            )),
                             type_arguments: arg.type_id.get_abi_type_arguments(
+                                handler,
                                 ctx,
                                 engines,
-                                types,
+                                metadata_types,
+                                concrete_types,
                                 arg.type_id,
-                            ),
+                                &mut new_metadata_types_to_add,
+                            )?,
                         })
-                        .collect::<Vec<_>>(),
-                )
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                if type_arguments.is_empty() {
+                    None
+                } else {
+                    metadata_types_to_add.extend(new_metadata_types_to_add);
+                    Some(type_arguments)
+                }
             }
 
             TypeInfo::Struct(decl_ref) => {
                 let decl = decl_engine.get_struct(decl_ref);
-                // Here, type_id for each type parameter should contain resolved types
-                let abi_type_arguments = decl
+
+                let mut new_metadata_types_to_add =
+                    Vec::<program_abi::TypeMetadataDeclaration>::new();
+                for v in decl.type_parameters.iter() {
+                    generate_type_metadata_declaration(
+                        handler,
+                        ctx,
+                        engines,
+                        metadata_types,
+                        concrete_types,
+                        v.type_id,
+                        v.type_id,
+                        &mut new_metadata_types_to_add,
+                    )?;
+                }
+
+                let type_arguments = decl
                     .type_parameters
                     .iter()
-                    .map(|v| program_abi::TypeDeclaration {
-                        type_id: v.type_id.index(),
-                        type_field: v.type_id.get_abi_type_str(
-                            &ctx.to_str_context(engines, false),
-                            engines,
-                            v.type_id,
-                        ),
-                        components: v
-                            .type_id
-                            .get_abi_type_components(ctx, engines, types, v.type_id),
-                        type_parameters: v
-                            .type_id
-                            .get_abi_type_parameters(ctx, engines, types, v.type_id),
+                    .map(|arg| {
+                        Ok(program_abi::TypeApplication {
+                            name: "".to_string(),
+                            type_id: program_abi::TypeId::Metadata(MetadataTypeId(
+                                arg.type_id.index(),
+                            )),
+                            type_arguments: arg.type_id.get_abi_type_arguments(
+                                handler,
+                                ctx,
+                                engines,
+                                metadata_types,
+                                concrete_types,
+                                arg.type_id,
+                                &mut new_metadata_types_to_add,
+                            )?,
+                        })
                     })
-                    .collect::<Vec<_>>();
-                types.extend(abi_type_arguments);
+                    .collect::<Result<Vec<_>, _>>()?;
 
+                if type_arguments.is_empty() {
+                    None
+                } else {
+                    metadata_types_to_add.extend(new_metadata_types_to_add);
+                    Some(type_arguments)
+                }
+            }
+            _ => None,
+        })
+    }
+
+    /// Return the type arguments of a given (potentially generic) type while considering what it
+    /// actually resolves to. These arguments are essentially of type of
+    /// `program_abi::TypeApplication`. The method below also updates the provided list of
+    /// `program_abi::TypeMetadataDeclaration`s  to add the newly discovered types.
+    pub(self) fn get_abi_type_arguments_as_concrete_type_ids(
+        &self,
+        handler: &Handler,
+        ctx: &mut AbiContext,
+        engines: &Engines,
+        metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+        concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+        resolved_type_id: TypeId,
+    ) -> Result<Option<Vec<program_abi::ConcreteTypeId>>, ErrorEmitted> {
+        let type_engine = engines.te();
+        let decl_engine = engines.de();
+        let resolved_params = resolved_type_id.get_type_parameters(engines);
+        Ok(match &*type_engine.get(*self) {
+            TypeInfo::Custom {
+                type_arguments: Some(type_arguments),
+                ..
+            } => (!type_arguments.is_empty()).then_some({
+                let resolved_params = resolved_params.unwrap_or_default();
+                type_arguments
+                    .iter()
+                    .zip(resolved_params.iter())
+                    .map(|(arg, p)| {
+                        generate_concrete_type_declaration(
+                            handler,
+                            ctx,
+                            engines,
+                            metadata_types,
+                            concrete_types,
+                            arg.initial_type_id,
+                            p.type_id,
+                        )
+                    })
+                    .collect::<Result<Vec<_>, _>>()?
+            }),
+            TypeInfo::Enum(decl_ref) => {
+                let decl = decl_engine.get_enum(decl_ref);
                 Some(
                     decl.type_parameters
                         .iter()
-                        .map(|arg| program_abi::TypeApplication {
-                            name: "".to_string(),
-                            type_id: arg.type_id.index(),
-                            type_arguments: arg.type_id.get_abi_type_arguments(
+                        .map(|arg| {
+                            generate_concrete_type_declaration(
+                                handler,
                                 ctx,
                                 engines,
-                                types,
+                                metadata_types,
+                                concrete_types,
                                 arg.type_id,
-                            ),
+                                arg.type_id,
+                            )
                         })
-                        .collect::<Vec<_>>(),
+                        .collect::<Result<Vec<_>, _>>()?,
+                )
+            }
+            TypeInfo::Struct(decl_ref) => {
+                let decl = decl_engine.get_struct(decl_ref);
+                Some(
+                    decl.type_parameters
+                        .iter()
+                        .map(|arg| {
+                            generate_concrete_type_declaration(
+                                handler,
+                                ctx,
+                                engines,
+                                metadata_types,
+                                concrete_types,
+                                arg.type_id,
+                                arg.type_id,
+                            )
+                        })
+                        .collect::<Result<Vec<_>, _>>()?,
                 )
             }
             _ => None,
-        }
+        })
     }
 }
 
 impl TyFunctionDecl {
     pub(self) fn generate_abi_function(
         &self,
+        handler: &Handler,
         ctx: &mut AbiContext,
         engines: &Engines,
-        types: &mut Vec<program_abi::TypeDeclaration>,
-    ) -> program_abi::ABIFunction {
-        // A list of all `program_abi::TypeDeclaration`s needed for inputs
-        let input_types = self
-            .parameters
-            .iter()
-            .map(|x| program_abi::TypeDeclaration {
-                type_id: x.type_argument.initial_type_id.index(),
-                type_field: x.type_argument.initial_type_id.get_abi_type_str(
-                    &ctx.to_str_context(engines, false),
-                    engines,
-                    x.type_argument.type_id,
-                ),
-                components: x.type_argument.initial_type_id.get_abi_type_components(
-                    ctx,
-                    engines,
-                    types,
-                    x.type_argument.type_id,
-                ),
-                type_parameters: x.type_argument.type_id.get_abi_type_parameters(
-                    ctx,
-                    engines,
-                    types,
-                    x.type_argument.type_id,
-                ),
-            })
-            .collect::<Vec<_>>();
-
-        // The single `program_abi::TypeDeclaration` needed for the output
-        let output_type = program_abi::TypeDeclaration {
-            type_id: self.return_type.initial_type_id.index(),
-            type_field: self.return_type.initial_type_id.get_abi_type_str(
-                &ctx.to_str_context(engines, false),
-                engines,
-                self.return_type.type_id,
-            ),
-            components: self.return_type.type_id.get_abi_type_components(
-                ctx,
-                engines,
-                types,
-                self.return_type.type_id,
-            ),
-            type_parameters: self.return_type.type_id.get_abi_type_parameters(
-                ctx,
-                engines,
-                types,
-                self.return_type.type_id,
-            ),
-        };
-
-        // Add the new types to `types`
-        types.extend(input_types);
-        types.push(output_type);
-
+        metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+        concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+    ) -> Result<program_abi::ABIFunction, ErrorEmitted> {
         // Generate the JSON data for the function
-        program_abi::ABIFunction {
+        Ok(program_abi::ABIFunction {
             name: self.name.as_str().to_string(),
             inputs: self
                 .parameters
                 .iter()
-                .map(|x| program_abi::TypeApplication {
-                    name: x.name.to_string(),
-                    type_id: x.type_argument.initial_type_id.index(),
-                    type_arguments: x.type_argument.initial_type_id.get_abi_type_arguments(
-                        ctx,
-                        engines,
-                        types,
-                        x.type_argument.type_id,
-                    ),
+                .map(|x| {
+                    Ok(program_abi::TypeConcreteParameter {
+                        name: x.name.to_string(),
+                        concrete_type_id: generate_concrete_type_declaration(
+                            handler,
+                            ctx,
+                            engines,
+                            metadata_types,
+                            concrete_types,
+                            x.type_argument.initial_type_id,
+                            x.type_argument.type_id,
+                        )?,
+                    })
                 })
-                .collect(),
-            output: program_abi::TypeApplication {
-                name: "".to_string(),
-                type_id: self.return_type.initial_type_id.index(),
-                type_arguments: self.return_type.initial_type_id.get_abi_type_arguments(
-                    ctx,
-                    engines,
-                    types,
-                    self.return_type.type_id,
-                ),
-            },
+                .collect::<Result<Vec<_>, _>>()?,
+            output: generate_concrete_type_declaration(
+                handler,
+                ctx,
+                engines,
+                metadata_types,
+                concrete_types,
+                self.return_type.initial_type_id,
+                self.return_type.type_id,
+            )?,
             attributes: generate_attributes_map(&self.attributes),
-        }
+        })
     }
 }
 
@@ -751,29 +1235,36 @@ fn generate_attributes_map(attr_map: &AttributesMap) -> Option<Vec<program_abi::
 
 impl TypeParameter {
     /// Returns the initial type ID of a TypeParameter. Also updates the provided list of types to
-    /// append the current TypeParameter as a `program_abi::TypeDeclaration`.
+    /// append the current TypeParameter as a `program_abi::TypeMetadataDeclaration`.
     pub(self) fn get_abi_type_parameter(
         &self,
+        handler: &Handler,
         ctx: &mut AbiContext,
         engines: &Engines,
-        types: &mut Vec<program_abi::TypeDeclaration>,
-    ) -> usize {
-        let type_parameter = program_abi::TypeDeclaration {
-            type_id: self.initial_type_id.index(),
+        metadata_types: &mut Vec<program_abi::TypeMetadataDeclaration>,
+        concrete_types: &mut Vec<program_abi::TypeConcreteDeclaration>,
+        metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
+    ) -> Result<MetadataTypeId, ErrorEmitted> {
+        let type_id = MetadataTypeId(self.initial_type_id.index());
+        let type_parameter = program_abi::TypeMetadataDeclaration {
+            metadata_type_id: type_id.clone(),
             type_field: self.initial_type_id.get_abi_type_str(
                 &ctx.to_str_context(engines, false),
                 engines,
                 self.type_id,
             ),
             components: self.initial_type_id.get_abi_type_components(
+                handler,
                 ctx,
                 engines,
-                types,
+                metadata_types,
+                concrete_types,
                 self.type_id,
-            ),
+                metadata_types_to_add,
+            )?,
             type_parameters: None,
         };
-        types.push(type_parameter);
-        self.initial_type_id.index()
+        metadata_types_to_add.push(type_parameter);
+        Ok(type_id)
     }
 }
diff --git a/sway-core/src/asm_generation/finalized_asm.rs b/sway-core/src/asm_generation/finalized_asm.rs
index 2fc0fe4326d..ce3c81e3a56 100644
--- a/sway-core/src/asm_generation/finalized_asm.rs
+++ b/sway-core/src/asm_generation/finalized_asm.rs
@@ -1,9 +1,9 @@
 use super::instruction_set::InstructionSet;
-use super::ToMidenBytecode;
 use super::{
     fuel::{checks, data_section::DataSection},
     ProgramABI, ProgramKind,
 };
+use crate::asm_generation::fuel::data_section::{DataId, Datum, Entry};
 use crate::asm_lang::allocated_ops::{AllocatedOp, AllocatedOpcode};
 use crate::decl_engine::DeclRefFunction;
 use crate::source_map::SourceMap;
@@ -77,10 +77,6 @@ impl FinalizedAsm {
                     })
                 }
             }
-            InstructionSet::MidenVM { ops } => Ok(CompiledBytecode {
-                bytecode: ops.to_bytecode().into(),
-                named_data_section_entries_offsets: Default::default(),
-            }),
         }
     }
 }
@@ -151,6 +147,13 @@ fn to_bytecode_mut(
         println!(";; --- START OF TARGET BYTECODE ---\n");
     }
 
+    let mut last_span = None;
+    let mut indentation = if build_config.print_bytecode_spans {
+        4
+    } else {
+        0
+    };
+
     let mut half_word_ix = 0;
     let mut offset_from_instr_start = 0;
     for op in ops.iter() {
@@ -165,7 +168,7 @@ fn to_bytecode_mut(
         match fuel_op {
             Either::Right(data) => {
                 if build_config.print_bytecode {
-                    print!("{:#010x} ", bytecode.len());
+                    print!("{}{:#010x} ", " ".repeat(indentation), bytecode.len());
                     println!(
                         "                                                ;; {:?}",
                         data
@@ -181,8 +184,45 @@ fn to_bytecode_mut(
             }
             Either::Left(instructions) => {
                 for instruction in instructions {
+                    // Print original source span only once
+                    if build_config.print_bytecode_spans {
+                        last_span = match (last_span, &span) {
+                            (None, Some(span)) => {
+                                indentation = 4;
+                                let line_col = span.start_pos().line_col();
+                                println!(
+                                    "{} @ {}:{}:{}",
+                                    span.as_str(),
+                                    span.source_id()
+                                        .map(|source_id| source_engine.get_path(source_id))
+                                        .map(|x| x.display().to_string())
+                                        .unwrap_or("<autogenerated>".to_string()),
+                                    line_col.line,
+                                    line_col.col
+                                );
+                                Some(span.clone())
+                            }
+                            (Some(last), Some(span)) if last != *span => {
+                                indentation = 4;
+                                let line_col = span.start_pos().line_col();
+                                println!(
+                                    "{} @ {}:{}:{}",
+                                    span.as_str(),
+                                    span.source_id()
+                                        .map(|source_id| source_engine.get_path(source_id))
+                                        .map(|x| x.display().to_string())
+                                        .unwrap_or("<autogenerated>".to_string()),
+                                    line_col.line,
+                                    line_col.col
+                                );
+                                Some(span.clone())
+                            }
+                            (last, _) => last,
+                        };
+                    }
+
                     if build_config.print_bytecode {
-                        print!("{:#010x} ", bytecode.len());
+                        print!("{}{:#010x} ", " ".repeat(indentation), bytecode.len());
                         print_instruction(&instruction);
                     }
 
@@ -202,8 +242,64 @@ fn to_bytecode_mut(
             }
         }
     }
+
     if build_config.print_bytecode {
-        println!("{}", data_section);
+        println!(".data_section:");
+
+        let offset = bytecode.len();
+
+        fn print_entry(indentation: usize, offset: usize, pair: &Entry) {
+            print!("{}{:#010x} ", " ".repeat(indentation), offset);
+
+            match &pair.value {
+                Datum::Byte(w) => println!(".byte i{w}, as hex {w:02X}"),
+                Datum::Word(w) => {
+                    println!(".word i{w}, as hex be bytes ({:02X?})", w.to_be_bytes())
+                }
+                Datum::ByteArray(bs) => {
+                    print!(".bytes as hex ({bs:02X?}), len i{}, as ascii \"", bs.len());
+
+                    for b in bs {
+                        print!(
+                            "{}",
+                            if *b == b' ' || b.is_ascii_graphic() {
+                                *b as char
+                            } else {
+                                '.'
+                            }
+                        );
+                    }
+                    println!("\"");
+                }
+                Datum::Slice(bs) => {
+                    print!(".slice as hex ({bs:02X?}), len i{}, as ascii \"", bs.len());
+
+                    for b in bs {
+                        print!(
+                            "{}",
+                            if *b == b' ' || b.is_ascii_graphic() {
+                                *b as char
+                            } else {
+                                '.'
+                            }
+                        );
+                    }
+                    println!("\"");
+                }
+                Datum::Collection(els) => {
+                    println!(".collection");
+                    for e in els {
+                        print_entry(indentation + 1, offset, e);
+                    }
+                }
+            };
+        }
+
+        for (i, entry) in data_section.value_pairs.iter().enumerate() {
+            let entry_offset = data_section.data_id_to_offset(&DataId(i as u32));
+            print_entry(indentation, offset + entry_offset, entry);
+        }
+
         println!(";; --- END OF TARGET BYTECODE ---\n");
     }
 
@@ -436,6 +532,8 @@ fn print_instruction(op: &Instruction) {
         Instruction::WDMM(x) => f("WDMM", x.unpack()),
         Instruction::WQMM(x) => f("WQMM", x.unpack()),
         Instruction::ECAL(x) => f("ECAL", x.unpack()),
+        Instruction::BSIZ(x) => f("BSIZ", x.unpack()),
+        Instruction::BLDD(x) => f("BLDD", x.unpack()),
     }
 }
 
@@ -450,6 +548,5 @@ pub fn check_invalid_opcodes(handler: &Handler, asm: &FinalizedAsm) -> Result<()
             ProgramKind::Predicate => checks::check_predicate_opcodes(handler, &ops[..]),
         },
         InstructionSet::Evm { ops: _ } => Ok(()),
-        InstructionSet::MidenVM { ops: _ } => Ok(()),
     }
 }
diff --git a/sway-core/src/asm_generation/from_ir.rs b/sway-core/src/asm_generation/from_ir.rs
index f29354c2fca..1a0435409ff 100644
--- a/sway-core/src/asm_generation/from_ir.rs
+++ b/sway-core/src/asm_generation/from_ir.rs
@@ -7,7 +7,6 @@ use super::{
         fuel_asm_builder::FuelAsmBuilder,
         register_sequencer::RegisterSequencer,
     },
-    MidenVMAsmBuilder,
 };
 use crate::{asm_generation::ProgramKind, BuildConfig, BuildTarget};
 
@@ -57,13 +56,6 @@ pub fn compile_ir_context_to_finalized_asm(
             build_config,
             EvmAsmBuilder::new(kind, ir),
         ),
-        BuildTarget::MidenVM => compile(
-            handler,
-            ir,
-            module,
-            build_config,
-            MidenVMAsmBuilder::new(kind, ir),
-        ),
     }?;
 
     check_invalid_opcodes(handler, &finalized_asm)?;
diff --git a/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs b/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs
index cd1156f38e8..32ef5a7f538 100644
--- a/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs
+++ b/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs
@@ -27,9 +27,10 @@ impl AbstractInstructionSet {
     pub(crate) fn optimize(self, data_section: &DataSection) -> AbstractInstructionSet {
         self.const_indexing_aggregates_function(data_section)
             .dce()
+            .simplify_cfg()
             .remove_sequential_jumps()
             .remove_redundant_moves()
-            .remove_unused_ops()
+            .remove_redundant_ops()
     }
 
     /// Removes any jumps to the subsequent line.
@@ -51,7 +52,7 @@ impl AbstractInstructionSet {
         for idx in dead_jumps {
             self.ops[idx] = Op {
                 opcode: Either::Left(VirtualOp::NOOP),
-                comment: "removed redundant JUMP".into(),
+                comment: "remove redundant jump operation".into(),
                 owning_span: None,
             };
         }
@@ -104,7 +105,7 @@ impl AbstractInstructionSet {
             for idx in dead_moves {
                 self.ops[idx] = Op {
                     opcode: Either::Left(VirtualOp::NOOP),
-                    comment: "removed redundant MOVE".into(),
+                    comment: "remove redundant move operation".into(),
                     owning_span: None,
                 };
             }
@@ -113,11 +114,18 @@ impl AbstractInstructionSet {
         self
     }
 
-    fn remove_unused_ops(mut self) -> AbstractInstructionSet {
-        // Just remove NOPs for now.
-        self.ops.retain(|op| match &op.opcode {
-            Either::Left(VirtualOp::NOOP) => false,
-            _otherwise => true,
+    fn remove_redundant_ops(mut self) -> AbstractInstructionSet {
+        self.ops.retain(|op| {
+            // It is easier to think in terms of operations we want to remove
+            // than the operations we want to retain ;-)
+            #[allow(clippy::match_like_matches_macro)]
+            // Keep the `match` for adding more ops in the future.
+            let remove = match &op.opcode {
+                Either::Left(VirtualOp::NOOP) => true,
+                _ => false,
+            };
+
+            !remove
         });
 
         self
diff --git a/sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs b/sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs
index 38466cf3edc..0865687f5c8 100644
--- a/sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs
+++ b/sway-core/src/asm_generation/fuel/allocated_abstract_instruction_set.rs
@@ -35,6 +35,30 @@ pub struct AllocatedAbstractInstructionSet {
 }
 
 impl AllocatedAbstractInstructionSet {
+    pub(crate) fn optimize(self) -> AllocatedAbstractInstructionSet {
+        self.remove_redundant_ops()
+    }
+
+    fn remove_redundant_ops(mut self) -> AllocatedAbstractInstructionSet {
+        self.ops.retain(|op| {
+            // It is easier to think in terms of operations we want to remove
+            // than the operations we want to retain ;-)
+            let remove = match &op.opcode {
+                // `cfei i0` and `cfsi i0` pairs.
+                Either::Left(AllocatedOpcode::CFEI(imm))
+                | Either::Left(AllocatedOpcode::CFSI(imm)) => imm.value == 0u32,
+                // `cfe $zero` and `cfs $zero` pairs.
+                Either::Left(AllocatedOpcode::CFE(reg))
+                | Either::Left(AllocatedOpcode::CFS(reg)) => reg.is_zero(),
+                _ => false,
+            };
+
+            !remove
+        });
+
+        self
+    }
+
     /// Replace each PUSHA instruction with stores of all used registers to the stack, and each
     /// POPA with respective loads from the stack.
     ///
@@ -120,15 +144,15 @@ impl AllocatedAbstractInstructionSet {
                     if mask_l.value != 0 {
                         new_ops.push(AllocatedAbstractOp {
                             opcode: Either::Left(AllocatedOpcode::PSHL(mask_l)),
-                            comment: "Save registers 16..40".into(),
-                            owning_span: None,
+                            comment: "save registers 16..40".into(),
+                            owning_span: op.owning_span.clone(),
                         });
                     }
                     if mask_h.value != 0 {
                         new_ops.push(AllocatedAbstractOp {
                             opcode: Either::Left(AllocatedOpcode::PSHH(mask_h)),
-                            comment: "Save registers 40..64".into(),
-                            owning_span: None,
+                            comment: "save registers 40..64".into(),
+                            owning_span: op.owning_span.clone(),
                         });
                     }
                 }
@@ -146,15 +170,15 @@ impl AllocatedAbstractInstructionSet {
                     if mask_h.value != 0 {
                         new_ops.push(AllocatedAbstractOp {
                             opcode: Either::Left(AllocatedOpcode::POPH(mask_h)),
-                            comment: "Restore registers 40..64".into(),
-                            owning_span: None,
+                            comment: "restore registers 40..64".into(),
+                            owning_span: op.owning_span.clone(),
                         });
                     }
                     if mask_l.value != 0 {
                         new_ops.push(AllocatedAbstractOp {
                             opcode: Either::Left(AllocatedOpcode::POPL(mask_l)),
-                            comment: "Restore registers 16..40".into(),
-                            owning_span: None,
+                            comment: "restore registers 16..40".into(),
+                            owning_span: op.owning_span.clone(),
                         });
                     }
                 }
@@ -299,7 +323,8 @@ impl AllocatedAbstractInstructionSet {
                                 AllocatedRegister::Constant(ConstantRegister::InstructionStart),
                             ),
                             owning_span: owning_span.clone(),
-                            comment: "Get current instruction offset from Instruction start".into(),
+                            comment: "get current instruction offset from instructions start ($is)"
+                                .into(),
                         });
                         realized_ops.push(RealizedOp {
                             opcode: AllocatedOpcode::SRLI(
@@ -308,7 +333,7 @@ impl AllocatedAbstractInstructionSet {
                                 VirtualImmediate12 { value: 2 },
                             ),
                             owning_span: owning_span.clone(),
-                            comment: "Current instruction offset in 32b words".into(),
+                            comment: "get current instruction offset in 32-bit words".into(),
                         });
                         realized_ops.push(RealizedOp {
                             opcode: AllocatedOpcode::ADDI(r1.clone(), r1, imm),
@@ -540,7 +565,7 @@ impl AllocatedAbstractInstructionSet {
                         if rel_offset(lab) == 0 {
                             new_ops.push(AllocatedAbstractOp {
                                 opcode: Either::Left(AllocatedOpcode::NOOP),
-                                comment: "NOP for self loop".into(),
+                                comment: "emit noop for self loop".into(),
                                 owning_span: None,
                             });
                             new_ops.push(op);
@@ -583,7 +608,7 @@ impl AllocatedAbstractInstructionSet {
                         if rel_offset(lab) == 0 {
                             new_ops.push(AllocatedAbstractOp {
                                 opcode: Either::Left(AllocatedOpcode::NOOP),
-                                comment: "NOP for self loop".into(),
+                                comment: "emit noop for self loop".into(),
                                 owning_span: None,
                             });
                             new_ops.push(op);
@@ -628,7 +653,7 @@ impl AllocatedAbstractInstructionSet {
                         if rel_offset(lab) <= consts::TWELVE_BITS {
                             new_ops.push(op)
                         } else {
-                            panic!("Return to address must be right after the call for which we saved this addr.");
+                            panic!("Return to address must be right after the call for which we saved this address.");
                         }
                     }
 
diff --git a/sway-core/src/asm_generation/fuel/data_section.rs b/sway-core/src/asm_generation/fuel/data_section.rs
index 10dc27f0da8..3db12443f4f 100644
--- a/sway-core/src/asm_generation/fuel/data_section.rs
+++ b/sway-core/src/asm_generation/fuel/data_section.rs
@@ -137,6 +137,9 @@ impl Entry {
             ConstantValue::Reference(_) => {
                 todo!("Constant references are currently not supported.")
             }
+            ConstantValue::Slice(_) => {
+                todo!("Constant slices are currently not supported.")
+            }
         }
     }
 
diff --git a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
index 9b8a6076e6f..b08361476c2 100644
--- a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
+++ b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
@@ -114,7 +114,7 @@ impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
                 self.globals_section.insert(name, size_in_bytes);
                 let global = self.globals_section.get_by_name(name).unwrap();
 
-                let (decode_fn_label, _) = self.func_label_map.get(decode_fn).unwrap();
+                let (decode_fn_label, _) = self.func_label_map.get(&decode_fn.get()).unwrap();
                 let dataid = self.data_section.insert_data_value(Entry::new_byte_array(
                     encoded_bytes.clone(),
                     Some(name.clone()),
@@ -126,7 +126,7 @@ impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
                         VirtualRegister::Constant(ConstantRegister::FuncArg0),
                         dataid,
                     )),
-                    comment: format!("ptr to {} default value", name),
+                    comment: format!("get pointer to configurable {} default value", name),
                     owning_span: None,
                 });
 
@@ -138,7 +138,7 @@ impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
                             value: encoded_bytes.len() as u16,
                         },
                     )),
-                    comment: format!("length of {} default value", name),
+                    comment: format!("get length of configurable {} default value", name),
                     owning_span: None,
                 });
 
@@ -150,7 +150,7 @@ impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
                             value: global.offset_in_bytes as u16,
                         },
                     )),
-                    comment: format!("ptr to global {} stack address", name),
+                    comment: format!("get pointer to configurable {} stack address", name),
                     owning_span: None,
                 });
 
@@ -159,14 +159,14 @@ impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
                 self.before_entries.push(Op::save_ret_addr(
                     VirtualRegister::Constant(ConstantRegister::CallReturnAddress),
                     ret_label,
-                    "",
+                    "set new return address",
                     None,
                 ));
 
                 // call decode
                 self.before_entries.push(Op {
                     opcode: Either::Right(crate::asm_lang::ControlFlowOp::Call(*decode_fn_label)),
-                    comment: format!("decode {}", name),
+                    comment: format!("decode configurable {}", name),
                     owning_span: None,
                 });
 
@@ -334,7 +334,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 self.cur_bytecode.push(Op::register_move(
                     arg_reg.clone(),
                     phi_reg.clone(),
-                    "parameter from branch to block argument",
+                    "move parameter from branch to block argument",
                     None,
                 ));
             }
@@ -354,7 +354,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
     ) -> Result<(), ErrorEmitted> {
         let Some(instruction) = instr_val.get_instruction(self.context) else {
             return Err(handler.emit_err(CompileError::Internal(
-                "Value not an instruction.",
+                "Value is not an instruction.",
                 self.md_mgr
                     .val_to_span(self.context, *instr_val)
                     .unwrap_or_else(Span::dummy),
@@ -543,7 +543,9 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                     const_copy.clone(),
                                     init_val_reg,
                                 )),
-                                comment: "copy const asm init to GP reg".into(),
+                                comment:
+                                    "copy ASM block argument's constant initial value to register"
+                                        .into(),
                                 owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
                             });
                             const_copy
@@ -609,10 +611,11 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             });
         }
 
-        // Now, load the designated asm return register into the desired return register, but only
-        // if it was named.
-        if let Some(ret_reg_name) = &asm_block.return_name {
-            // Lookup and replace the return register.
+        // ASM block always returns a value. The return value is either the one contained in
+        // the return register specified at the end of the ASM block, or it is unit, `()`, in
+        // the case of an ASM block without the return register specified.
+        let (ret_reg, comment) = if let Some(ret_reg_name) = &asm_block.return_name {
+            // If the return register is specified, lookup it by name.
             let ret_reg = match realize_register(ret_reg_name.as_str()) {
                 Some(reg) => reg,
                 None => {
@@ -626,14 +629,40 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     }));
                 }
             };
-            let instr_reg = self.reg_seqr.next();
-            inline_ops.push(Op {
-                opcode: Either::Left(VirtualOp::MOVE(instr_reg.clone(), ret_reg)),
-                comment: format!("return value from inline asm ({})", ret_reg_name),
-                owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
-            });
-            self.reg_map.insert(*instr_val, instr_reg);
-        }
+
+            (
+                ret_reg,
+                format!(
+                    "return value from ASM block with return register {}",
+                    ret_reg_name
+                ),
+            )
+        } else {
+            // If the return register is not specified, the return value is unit, `()`, and we
+            // move constant register $zero to the final instruction register.
+            if !asm_block.return_type.is_unit(self.context) {
+                return Err(handler.emit_err(CompileError::InternalOwned(
+                    format!("Return type of an ASM block without return register must be unit, but it was {}.", asm_block.return_type.as_string(self.context)),
+                    self.md_mgr
+                        .val_to_span(self.context, *instr_val)
+                        .unwrap_or_else(Span::dummy),
+                )));
+            }
+
+            (
+                VirtualRegister::Constant(ConstantRegister::Zero),
+                "return unit value from ASM block without return register".into(),
+            )
+        };
+
+        // Move the return register to the instruction register.
+        let instr_reg = self.reg_seqr.next();
+        inline_ops.push(Op {
+            opcode: Either::Left(VirtualOp::MOVE(instr_reg.clone(), ret_reg)),
+            comment,
+            owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
+        });
+        self.reg_map.insert(*instr_val, instr_reg);
 
         self.cur_bytecode.append(&mut inline_ops);
 
@@ -648,7 +677,8 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
     ) -> Result<(), CompileError> {
         let val_reg = self.value_to_register(bitcast_val)?;
         let reg = if to_type.is_bool(self.context) {
-            // This may not be necessary if we just treat a non-zero value as 'true'.
+            // We treat only one as `true`, and not every non-zero value.
+            // So, every non-zero value must be converted to one.
             let res_reg = self.reg_seqr.next();
             self.cur_bytecode.push(Op {
                 opcode: Either::Left(VirtualOp::EQ(
@@ -656,7 +686,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     val_reg,
                     VirtualRegister::Constant(ConstantRegister::Zero),
                 )),
-                comment: "convert to inversed boolean".into(),
+                comment: "[bitcast to bool]: convert value to inverted boolean".into(),
                 owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
             });
             self.cur_bytecode.push(Op {
@@ -665,13 +695,15 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     res_reg.clone(),
                     VirtualImmediate12 { value: 1 },
                 )),
-                comment: "invert boolean".into(),
+                comment: "[bitcast to bool]: invert inverted boolean".into(),
                 owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
             });
             res_reg
+        } else if to_type.is_unit(self.context) {
+            // Unit is represented as zero.
+            VirtualRegister::Constant(ConstantRegister::Zero)
         } else {
-            // This is a no-op, although strictly speaking Unit should probably be compiled as
-            // a zero.
+            // For all other values, bitcast is a no-op.
             val_reg
         };
         self.reg_map.insert(*instr_val, reg);
@@ -1019,7 +1051,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 self.cur_bytecode.push(Op::register_move(
                     phi_reg.clone(),
                     local_reg,
-                    "parameter from branch to block argument",
+                    "move parameter from branch to block argument",
                     None,
                 ));
             }
@@ -1052,13 +1084,13 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
         });
 
-        // now, move the return value of the contract call to the return register.
+        // Now, move the return value of the contract call to the return register.
         // TODO validate RETL matches the expected type (this is a comment from the old codegen)
         let instr_reg = self.reg_seqr.next();
         self.cur_bytecode.push(Op::register_move(
             instr_reg.clone(),
             VirtualRegister::Constant(ConstantRegister::ReturnValue),
-            "save call result",
+            "save external contract call result",
             None,
         ));
         self.reg_map.insert(*instr_val, instr_reg);
@@ -1153,7 +1185,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         array_elem_size,
                         size_reg.clone(),
                         None,
-                        "get size of element",
+                        "get array element size",
                         owning_span.clone(),
                     );
 
@@ -1175,7 +1207,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             reg,
                             offset_reg.clone(),
                         )),
-                        comment: "add to array base".into(),
+                        comment: "add array element offset to array base".into(),
                         owning_span: owning_span.clone(),
                     });
 
@@ -1198,7 +1230,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 const_offs,
                 instr_reg.clone(),
                 Some(&base_reg),
-                "get offset to element",
+                "get offset to aggregate element",
                 owning_span.clone(),
             );
             self.reg_map.insert(*instr_val, instr_reg);
@@ -1312,7 +1344,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         value: g.offset_in_bytes as u16,
                     },
                 )),
-                comment: format!("configurable {} address", name),
+                comment: format!("get address of configurable {}", name),
                 owning_span: self.md_mgr.val_to_span(self.context, *addr_val),
             });
             self.reg_map.insert(*addr_val, addr_reg);
@@ -1324,7 +1356,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     addr_reg.clone(),
                     dataid.clone(),
                 )),
-                comment: format!("configurable {} address", name),
+                comment: format!("get address of configurable {}", name),
                 owning_span: self.md_mgr.val_to_span(self.context, *addr_val),
             });
             self.reg_map.insert(*addr_val, addr_reg);
@@ -1381,7 +1413,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         src_reg,
                         VirtualImmediate12 { value: 0 },
                     )),
-                    comment: "load value".into(),
+                    comment: "load byte".into(),
                     owning_span,
                 });
             }
@@ -1392,7 +1424,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         src_reg,
                         VirtualImmediate12 { value: 0 },
                     )),
-                    comment: "load value".into(),
+                    comment: "load word".into(),
                     owning_span,
                 });
             }
@@ -1433,13 +1465,13 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     value: byte_len as u32,
                 },
             )),
-            comment: "get length for mcp".into(),
+            comment: "get data length for memory copy".into(),
             owning_span: owning_span.clone(),
         });
 
         self.cur_bytecode.push(Op {
             opcode: Either::Left(VirtualOp::MCP(dst_reg, src_reg, len_reg)),
-            comment: "copy memory with mem_copy".into(),
+            comment: "copy memory".into(),
             owning_span,
         });
 
@@ -1487,7 +1519,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     VirtualRegister::Constant(ConstantRegister::Zero),
                     VirtualRegister::Constant(ConstantRegister::Zero),
                 )),
-                comment: "".into(),
+                comment: "log non-pointer value".into(),
             });
         } else {
             // If the type is a pointer then we use LOGD to log the data. First put the size into
@@ -1507,7 +1539,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         VirtualImmediate12 { value: 0 },
                     )),
                     owning_span: owning_span.clone(),
-                    comment: "load slice ptr".into(),
+                    comment: "load slice pointer for logging data".into(),
                 });
                 self.cur_bytecode.push(Op {
                     opcode: Either::Left(VirtualOp::LW(
@@ -1516,7 +1548,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         VirtualImmediate12 { value: 1 },
                     )),
                     owning_span: owning_span.clone(),
-                    comment: "load slice size".into(),
+                    comment: "load slice size for logging data".into(),
                 });
                 self.cur_bytecode.push(Op {
                     owning_span,
@@ -1536,7 +1568,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     size_in_bytes,
                     size_reg.clone(),
                     None,
-                    "loading size for LOGD",
+                    "load data size for logging data",
                     owning_span.clone(),
                 );
 
@@ -1548,7 +1580,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         log_val_reg.clone(),
                         size_reg,
                     )),
-                    comment: "log ptr".into(),
+                    comment: "log data".into(),
                 });
             }
         }
@@ -1578,7 +1610,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     sway_ir::Register::Flag => ConstantRegister::Flags,
                 }),
             )),
-            comment: "move register into abi function".to_owned(),
+            comment: "read special register".to_owned(),
             owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
         });
 
@@ -1601,7 +1633,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     ConstantRegister::Zero,
                 ))),
                 owning_span,
-                comment: "returning unit as zero".into(),
+                comment: "return unit as zero".into(),
             });
         } else {
             let ret_reg = self.value_to_register(ret_val)?;
@@ -1636,7 +1668,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             VirtualImmediate12 { value: 0 },
                         )),
                         owning_span: owning_span.clone(),
-                        comment: "load ptr of returned slice".into(),
+                        comment: "load pointer to returned slice".into(),
                     });
                 } else {
                     let size_in_bytes = ret_type
@@ -1648,7 +1680,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         size_in_bytes,
                         size_reg.clone(),
                         None,
-                        "get size of returned ref",
+                        "get size of type returned by pointer",
                         owning_span.clone(),
                     );
                 }
@@ -1693,7 +1725,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 VirtualRegister::Constant(ConstantRegister::HeapPointer),
                 VirtualImmediate12::new(0, Span::dummy()).unwrap(),
             )),
-            comment: "jmp_mem: Load MEM[$hp]".into(),
+            comment: "[jump]: load word from MEM[$hp]".into(),
         });
         self.cur_bytecode.push(Op {
             owning_span: owning_span.clone(),
@@ -1702,7 +1734,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 target_reg,
                 VirtualRegister::Constant(ConstantRegister::InstructionStart),
             )),
-            comment: "jmp_mem: Subtract $is since Jmp adds it back.".into(),
+            comment: "[jump]: subtract instructions start ($is) since jmp adds it back".into(),
         });
         self.cur_bytecode.push(Op {
             owning_span: owning_span.clone(),
@@ -1711,13 +1743,13 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 is_target_reg.clone(),
                 VirtualImmediate12::new(4, Span::dummy()).unwrap(),
             )),
-            comment: "jmp_mem: Divide by 4 since Jmp multiplies by 4.".into(),
+            comment: "[jump]: divide by 4 since jmp multiplies by 4".into(),
         });
 
         self.cur_bytecode.push(Op {
             owning_span,
             opcode: Either::Left(VirtualOp::JMP(by4_reg)),
-            comment: "jmp_mem: Jump to computed value".into(),
+            comment: "[jump]: jump to computed value".into(),
         });
 
         Ok(())
@@ -1785,7 +1817,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 was_slot_set_reg.clone(),
                 number_of_slots_reg,
             )),
-            comment: "clear a sequence of storage slots".into(),
+            comment: "clear sequence of storage slots".into(),
             owning_span,
         });
 
@@ -1839,7 +1871,13 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     number_of_slots_reg,
                 ),
             }),
-            comment: "access a sequence of storage slots".into(),
+            comment: format!(
+                "{} sequence of storage slots",
+                match access_type {
+                    StateAccessType::Read => "read",
+                    StateAccessType::Write => "write",
+                }
+            ),
             owning_span,
         });
 
@@ -1872,7 +1910,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
 
         self.cur_bytecode.push(Op {
             opcode: Either::Left(VirtualOp::SRW(load_reg.clone(), was_slot_set_reg, key_reg)),
-            comment: "single word state access".into(),
+            comment: "read single word from contract state".into(),
             owning_span,
         });
 
@@ -1909,7 +1947,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
 
         self.cur_bytecode.push(Op {
             opcode: Either::Left(VirtualOp::SWW(key_reg, was_slot_set_reg.clone(), store_reg)),
-            comment: "single word state access".into(),
+            comment: "write single word to contract state".into(),
             owning_span,
         });
 
@@ -1949,7 +1987,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             val_reg,
                             VirtualImmediate12 { value: 0 },
                         )),
-                        comment: "store value".into(),
+                        comment: "store byte".into(),
                         owning_span,
                     });
                 }
@@ -1960,7 +1998,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             val_reg,
                             VirtualImmediate12 { value: 0 },
                         )),
-                        comment: "store value".into(),
+                        comment: "store word".into(),
                         owning_span,
                     });
                 }
@@ -2015,7 +2053,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 (VirtualRegister::Constant(ConstantRegister::Zero), None)
             }
 
-            ConstantValue::Uint(1) if config_name.is_none() => {
+            ConstantValue::Uint(1) | ConstantValue::Bool(true) if config_name.is_none() => {
                 (VirtualRegister::Constant(ConstantRegister::One), None)
             }
 
@@ -2031,7 +2069,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         reg.clone(),
                         data_id.clone(),
                     )),
-                    comment: "literal instantiation".into(),
+                    comment: "load constant from data section".into(),
                     owning_span: span,
                 });
                 (reg, Some(data_id))
@@ -2055,7 +2093,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         // to determine when it may be initialised and/or reused.
     }
 
-    // Get the reg corresponding to `value`. Returns an ICE if the value is not in reg_map or is
+    // Get the reg corresponding to `value`. Returns an ICE if the value is not in `reg_map` or is
     // not a constant.
     pub(super) fn value_to_register(
         &mut self,
@@ -2080,7 +2118,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             let reg = self.reg_seqr.next();
                             self.cur_bytecode.push(Op {
                                 opcode: Either::Left(VirtualOp::MOVI(reg.clone(), imm)),
-                                comment: "initializer constant into register".into(),
+                                comment: "initialize constant into register".into(),
                                 owning_span: None,
                             });
                             reg
diff --git a/sway-core/src/asm_generation/fuel/functions.rs b/sway-core/src/asm_generation/fuel/functions.rs
index fed3a7ed0a3..42577c543d6 100644
--- a/sway-core/src/asm_generation/fuel/functions.rs
+++ b/sway-core/src/asm_generation/fuel/functions.rs
@@ -79,54 +79,14 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 self.cur_bytecode.push(Op::register_move(
                     VirtualRegister::Constant(ConstantRegister::ARG_REGS[idx]),
                     arg_reg,
-                    format!("pass arg {idx}"),
+                    format!("[call]: pass argument {idx}"),
                     self.md_mgr.val_to_span(self.context, *arg_val),
                 ));
             }
         } else {
-            // Put NUM_ARG_REGISTERS - 1 arguments into arg registers and rest into the stack.
-            for (idx, arg_val) in args.iter().enumerate() {
-                let arg_reg = self.value_to_register(arg_val)?;
-                // Except for the last arg register, the others hold an argument.
-                if idx < compiler_constants::NUM_ARG_REGISTERS as usize - 1 {
-                    self.cur_bytecode.push(Op::register_move(
-                        VirtualRegister::Constant(ConstantRegister::ARG_REGS[idx]),
-                        arg_reg,
-                        format!("pass arg {idx}"),
-                        self.md_mgr.val_to_span(self.context, *arg_val),
-                    ));
-                } else {
-                    // All arguments [NUM_ARG_REGISTERS - 1 ..] go into the stack.
-                    assert!(
-                        self.locals_size_bytes() % 8 == 0,
-                        "The size of locals is not word aligned"
-                    );
-                    let stack_offset_bytes = self.locals_size_bytes()
-                        + (((idx as u64 + 1) - compiler_constants::NUM_ARG_REGISTERS as u64) * 8);
-                    assert!(
-                        stack_offset_bytes
-                            < self.locals_size_bytes() + (self.max_num_extra_args() * 8)
-                    );
-                    self.cur_bytecode.push(Op {
-                        opcode: Either::Left(VirtualOp::SW(
-                            VirtualRegister::Constant(ConstantRegister::LocalsBase),
-                            arg_reg,
-                            VirtualImmediate12::new(
-                                // The VM multiples the offset by 8, so we divide it by 8.
-                                stack_offset_bytes / 8,
-                                self.md_mgr
-                                    .val_to_span(self.context, *arg_val)
-                                    .unwrap_or(Span::dummy()),
-                            )
-                            .expect("Too many arguments, cannot handle."),
-                        )),
-                        comment: format!("Pass arg {idx} via its stack slot"),
-                        owning_span: self.md_mgr.val_to_span(self.context, *arg_val),
-                    });
-                }
-            }
             // Register ARG_REGS[NUM_ARG_REGISTERS-1] must contain LocalsBase + locals_size
             // so that the callee can index the stack arguments from there.
+            // It's also useful for us to save the arguments to the stack next.
             if self.locals_size_bytes() <= TWELVE_BITS {
                 self.cur_bytecode.push(Op {
                     opcode: Either::Left(VirtualOp::ADDI(
@@ -138,7 +98,8 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         VirtualImmediate12::new(self.locals_size_bytes(), Span::dummy())
                             .expect("Stack size too big for these many arguments, cannot handle."),
                     )),
-                    comment: "Save address of stack arguments in last arg register".to_string(),
+                    comment: "[call]: save address of stack arguments in last argument register"
+                        .to_string(),
                     owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
                 });
             } else {
@@ -151,7 +112,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         VirtualImmediate18::new(self.locals_size_bytes(), Span::dummy())
                             .expect("Stack size too big for these many arguments, cannot handle."),
                     )),
-                    comment: "Temporarily save the locals size to add up next".to_string(),
+                    comment: "[call]: temporarily save locals size to add up next".to_string(),
                     owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
                 });
                 self.cur_bytecode.push(Op {
@@ -166,10 +127,56 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                 [(compiler_constants::NUM_ARG_REGISTERS - 1) as usize],
                         ),
                     )),
-                    comment: "Save address of stack arguments in last arg register".to_string(),
+                    comment: "[call]: save address of stack arguments in last argument register"
+                        .to_string(),
                     owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
                 });
             }
+
+            // Put NUM_ARG_REGISTERS - 1 arguments into arg registers and rest into the stack.
+            for (idx, arg_val) in args.iter().enumerate() {
+                let arg_reg = self.value_to_register(arg_val)?;
+                // Except for the last arg register, the others hold an argument.
+                if idx < compiler_constants::NUM_ARG_REGISTERS as usize - 1 {
+                    self.cur_bytecode.push(Op::register_move(
+                        VirtualRegister::Constant(ConstantRegister::ARG_REGS[idx]),
+                        arg_reg,
+                        format!("[call]: pass argument {idx}"),
+                        self.md_mgr.val_to_span(self.context, *arg_val),
+                    ));
+                } else {
+                    // All arguments [NUM_ARG_REGISTERS - 1 ..] go into the stack.
+                    assert!(
+                        self.locals_size_bytes() % 8 == 0,
+                        "The size of locals is not word aligned"
+                    );
+                    let stack_offset =
+                        (idx as u64 + 1) - compiler_constants::NUM_ARG_REGISTERS as u64;
+                    let stack_offset_bytes = self.locals_size_bytes() + (stack_offset * 8);
+                    assert!(
+                        stack_offset_bytes
+                            < self.locals_size_bytes() + (self.max_num_extra_args() * 8)
+                    );
+                    self.cur_bytecode.push(Op {
+                        opcode: Either::Left(VirtualOp::SW(
+                            VirtualRegister::Constant(
+                                ConstantRegister::ARG_REGS
+                                    [compiler_constants::NUM_ARG_REGISTERS as usize - 1],
+                            ),
+                            arg_reg,
+                            VirtualImmediate12::new(
+                                stack_offset,
+                                self.md_mgr
+                                    .val_to_span(self.context, *arg_val)
+                                    .unwrap_or(Span::dummy()),
+                            )
+                            .expect("Too many arguments, cannot handle."),
+                        )),
+                        comment: format!("[call]: pass argument {idx} via its stack slot"),
+                        owning_span: self.md_mgr.val_to_span(self.context, *arg_val),
+                    });
+                }
+            }
         }
 
         // Set a new return address.
@@ -177,7 +184,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         self.cur_bytecode.push(Op::save_ret_addr(
             VirtualRegister::Constant(ConstantRegister::CallReturnAddress),
             ret_label,
-            "set new return addr",
+            "[call]: set new return address",
             None,
         ));
 
@@ -185,7 +192,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         let (fn_label, _) = self.func_to_labels(function);
         self.cur_bytecode.push(Op {
             opcode: Either::Right(OrganizationalOp::Call(fn_label)),
-            comment: format!("call {}", function.get_name(self.context)),
+            comment: format!("[call]: call {}", function.get_name(self.context)),
             owning_span: None,
         });
         self.cur_bytecode.push(Op::unowned_jump_label(ret_label));
@@ -197,7 +204,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 ret_reg.clone(),
                 VirtualRegister::Constant(ConstantRegister::CallReturnValue),
             )),
-            comment: "copy the return value".into(),
+            comment: "[call]: copy the return value".into(),
             owning_span: None,
         });
         self.reg_map.insert(*instr_val, ret_reg);
@@ -274,8 +281,8 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             function.get_name(self.context)
         );
 
-        self.cur_bytecode.push(match span {
-            Some(span) => Op::jump_label_comment(start_label, span, comment),
+        self.cur_bytecode.push(match &span {
+            Some(span) => Op::jump_label_comment(start_label, span.clone(), comment),
             None => Op::unowned_jump_label_comment(start_label, comment),
         });
 
@@ -284,8 +291,8 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             // Save any general purpose registers used here on the stack.
             self.cur_bytecode.push(Op {
                 opcode: Either::Right(OrganizationalOp::PushAll(start_label)),
-                comment: "save all regs".to_owned(),
-                owning_span: None,
+                comment: "save all registers".to_owned(),
+                owning_span: span.clone(),
             });
         }
 
@@ -305,14 +312,14 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             self.cur_bytecode.push(Op::register_move(
                 reta.clone(),
                 VirtualRegister::Constant(ConstantRegister::CallReturnAddress),
-                "save reta",
+                "save return address",
                 None,
             ));
             let retv = self.reg_seqr.next();
             self.cur_bytecode.push(Op::register_move(
                 retv.clone(),
                 VirtualRegister::Constant(ConstantRegister::CallReturnValue),
-                "save retv",
+                "save return value",
                 None,
             ));
 
@@ -346,14 +353,14 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             self.cur_bytecode.push(Op::register_move(
                 VirtualRegister::Constant(ConstantRegister::CallReturnAddress),
                 reta,
-                "restore reta",
+                "restore return address",
                 None,
             ));
 
             // Restore GP regs.
             self.cur_bytecode.push(Op {
                 opcode: Either::Right(OrganizationalOp::PopAll(start_label)),
-                comment: "restore all regs".to_owned(),
+                comment: "restore all registers".to_owned(),
                 owning_span: None,
             });
 
@@ -387,7 +394,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 self.cur_bytecode.push(Op::register_move(
                     arg_copy_reg.clone(),
                     VirtualRegister::Constant(ConstantRegister::ARG_REGS[idx]),
-                    format!("save arg {idx} ({arg_name})"),
+                    format!("save argument {idx} ({arg_name})"),
                     self.md_mgr.val_to_span(self.context, *arg_val),
                 ));
 
@@ -396,7 +403,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             }
         } else {
             // Get NUM_ARG_REGISTERS - 1 arguments from arg registers and rest from the stack.
-            for (idx, (_, arg_val)) in function.args_iter(self.context).enumerate() {
+            for (idx, (arg_name, arg_val)) in function.args_iter(self.context).enumerate() {
                 let arg_copy_reg = self.reg_seqr.next();
                 // Except for the last arg register, the others hold an argument.
                 if idx < compiler_constants::NUM_ARG_REGISTERS as usize - 1 {
@@ -404,7 +411,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     self.cur_bytecode.push(Op::register_move(
                         arg_copy_reg.clone(),
                         VirtualRegister::Constant(ConstantRegister::ARG_REGS[idx]),
-                        format!("save arg {idx}"),
+                        format!("save argument {idx} ({arg_name})"),
                         self.md_mgr.val_to_span(self.context, *arg_val),
                     ));
                 } else {
@@ -430,7 +437,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             )
                             .expect("Too many arguments, cannot handle."),
                         )),
-                        comment: format!("Load arg {idx} from its stack slot"),
+                        comment: format!("load argument {idx} ({arg_name}) from its stack slot"),
                         owning_span: self.md_mgr.val_to_span(self.context, *arg_val),
                     });
                 }
@@ -475,7 +482,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                     single_arg_reg.clone(),
                                     VirtualImmediate12 { value: 0 },
                                 )),
-                                comment: "load main fn parameter".into(),
+                                comment: "load main function parameter".into(),
                                 owning_span: None,
                             });
                         }
@@ -519,7 +526,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                     args_base_reg.clone(),
                                     offs_reg.clone(),
                                 )),
-                                comment: format!("get offset for arg {name}"),
+                                comment: format!("get offset of argument {name}"),
                                 owning_span: None,
                             });
 
@@ -530,7 +537,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                         offs_reg,
                                         VirtualImmediate12 { value: 0 },
                                     )),
-                                    comment: format!("get arg {name}"),
+                                    comment: format!("get argument {name}"),
                                     owning_span: None,
                                 });
                             } else {
@@ -540,7 +547,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                         offs_reg,
                                         VirtualImmediate12 { value: 0 },
                                     )),
-                                    comment: format!("get arg {name}"),
+                                    comment: format!("get argument {name}"),
                                     owning_span: None,
                                 });
                             }
@@ -553,7 +560,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                         value: arg_word_offset as u16 * 8,
                                     },
                                 )),
-                                comment: format!("get arg {name}"),
+                                comment: format!("get argument {name}"),
                                 owning_span: None,
                             });
                         } else {
@@ -565,7 +572,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                                         value: arg_word_offset as u16,
                                     },
                                 )),
-                                comment: format!("get arg {name}"),
+                                comment: format!("get argument {name}"),
                                 owning_span: None,
                             });
                         }
@@ -574,7 +581,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             arg_word_offset * 8,
                             current_arg_reg.clone(),
                             Some(&args_base_reg),
-                            format!("get offset or arg {name}"),
+                            format!("get offset of argument {name}"),
                             None,
                         );
                     }
@@ -597,7 +604,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 // see https://github.com/FuelLabs/fuel-specs/pull/193#issuecomment-876496372
                 VirtualImmediate12 { value: 74 },
             )),
-            comment: "base register for method parameter".into(),
+            comment: "get base register for method arguments".into(),
             owning_span: None,
         });
     }
@@ -612,7 +619,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     value: GTFArgs::ScriptData as u16,
                 },
             )),
-            comment: "base register for main fn parameter".into(),
+            comment: "get base register for main function arguments".into(),
             owning_span: None,
         });
     }
@@ -650,7 +657,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     value: GTFArgs::InputType as u16,
                 },
             )),
-            comment: "get input type".into(),
+            comment: "get predicate input type".into(),
             owning_span: None,
         });
 
@@ -671,7 +678,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     value: GTFArgs::InputCoinPredicateData as u16,
                 },
             )),
-            comment: "get input coin predicate data pointer".into(),
+            comment: "get predicate input coin data pointer".into(),
             owning_span: None,
         });
 
@@ -692,7 +699,9 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 two.clone(),
                 VirtualImmediate18 { value: 2u32 },
             )),
-            comment: "register containing 2".into(),
+            comment:
+                "[predicate input is message]: set register to 2 (Input::Message discriminator)"
+                    .into(),
             owning_span: None,
         });
         self.cur_bytecode.push(Op {
@@ -701,7 +710,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 input_type,
                 two,
             )),
-            comment: "input type is message(2)".into(),
+            comment: "[predicate input is message]: check if input type is message".into(),
             owning_span: None,
         });
 
@@ -713,16 +722,17 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 input_type_is_message,
                 VirtualImmediate12 { value: 1 },
             )),
-            comment: "input type is not message(2)".into(),
+            comment: "[predicate input is message]: check if input type is not message".into(),
             owning_span: None,
         });
 
         // Label to jump to if the input type is *not* 2, i.e. not "message" (and not "coin" since
         // we checked that earlier). Then do the jump.
         let input_type_not_message_label = self.reg_seqr.get_label();
-        self.cur_bytecode.push(Op::jump_if_not_zero(
+        self.cur_bytecode.push(Op::jump_if_not_zero_comment(
             input_type_not_message,
             input_type_not_message_label,
+            "[predicate input is message]: jump to return false from predicate",
         ));
 
         // If the input is indeed a "message", then use `GTF` to get the "input message predicate
@@ -735,7 +745,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     value: GTFArgs::InputMessagePredicateData as u16,
                 },
             )),
-            comment: "input message predicate data pointer".into(),
+            comment: "get predicate input message data pointer".into(),
             owning_span: None,
         });
         self.cur_bytecode.push(Op::jump_to_label(success_label));
@@ -751,7 +761,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                 ConstantRegister::Zero,
             ))),
             owning_span: None,
-            comment: "return false".into(),
+            comment: "return false from predicate".into(),
         });
 
         // Final success label to continue execution at if we successfully obtained the predicate
@@ -873,7 +883,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             locals_base_reg.clone(),
             VirtualRegister::Constant(ConstantRegister::StackPointer),
             format!(
-                "save locals base register for {}",
+                "save locals base register for function {}",
                 function.get_name(self.context)
             )
             .to_string(),
@@ -888,7 +898,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             opcode: Either::Left(VirtualOp::CFEI(VirtualImmediate24 {
                 value: locals_size_bytes as u32 + (max_num_extra_args * 8) as u32,
             })),
-            comment: format!("allocate {locals_size_bytes} bytes for locals and {max_num_extra_args} slots for call arguments."),
+            comment: format!("allocate {locals_size_bytes} bytes for locals and {max_num_extra_args} slots for call arguments"),
             owning_span: None,
         });
         (
@@ -927,7 +937,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             data_id,
                         )),
-                        comment: "load initializer from data section".to_owned(),
+                        comment: "load local variable initializer from data section".to_owned(),
                         owning_span: None,
                     });
                 }
@@ -938,7 +948,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             c.clone(),
                         )),
-                        comment: "load initializer from register".into(),
+                        comment: "load local variable initializer from register".into(),
                         owning_span: None,
                     });
                 }
@@ -958,7 +968,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             value: var_stack_off_bytes as u16,
                         },
                     )),
-                    comment: "calc local variable address".to_owned(),
+                    comment: "get local variable address".to_owned(),
                     owning_span: None,
                 });
             } else {
@@ -971,7 +981,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             value: var_stack_off_bytes as u32,
                         },
                     )),
-                    comment: "stack offset of local variable into register".to_owned(),
+                    comment: "move stack offset of local variable into register".to_owned(),
                     owning_span: None,
                 });
                 self.cur_bytecode.push(Op {
@@ -980,7 +990,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         locals_base_reg.clone(),
                         dst_reg.clone(),
                     )),
-                    comment: "calc local variable address".to_owned(),
+                    comment: "get local variable address".to_owned(),
                     owning_span: None,
                 });
             }
@@ -994,7 +1004,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             VirtualImmediate12 { value: 0 },
                         )),
-                        comment: "store initializer to local variable".to_owned(),
+                        comment: "store byte initializer to local variable".to_owned(),
                         owning_span: None,
                     });
                 } else {
@@ -1004,7 +1014,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             VirtualImmediate12 { value: 0 },
                         )),
-                        comment: "store initializer to local variable".to_owned(),
+                        comment: "store word initializer to local variable".to_owned(),
                         owning_span: None,
                     });
                 }
@@ -1039,7 +1049,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             opcode: Either::Left(VirtualOp::CFSI(VirtualImmediate24 {
                 value: u32::try_from(locals_size_bytes + (max_num_extra_args * 8)).unwrap(),
             })),
-            comment: format!("free {locals_size_bytes} bytes for locals and {max_num_extra_args} slots for extra call arguments."),
+            comment: format!("free {locals_size_bytes} bytes for locals and {max_num_extra_args} slots for extra call arguments"),
             owning_span: None,
         });
     }
diff --git a/sway-core/src/asm_generation/fuel/optimizations.rs b/sway-core/src/asm_generation/fuel/optimizations.rs
index 63fd044c039..4800ba6906f 100644
--- a/sway-core/src/asm_generation/fuel/optimizations.rs
+++ b/sway-core/src/asm_generation/fuel/optimizations.rs
@@ -1,11 +1,11 @@
-use std::collections::BTreeSet;
+use std::collections::{BTreeSet, HashMap};
 
 use either::Either;
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
     asm_generation::fuel::compiler_constants,
-    asm_lang::{ControlFlowOp, VirtualImmediate12, VirtualOp, VirtualRegister},
+    asm_lang::{ControlFlowOp, Label, VirtualImmediate12, VirtualOp, VirtualRegister},
 };
 
 use super::{
@@ -269,4 +269,44 @@ impl AbstractInstructionSet {
 
         self
     }
+
+    // Remove unreachable instructions.
+    pub(crate) fn simplify_cfg(mut self) -> AbstractInstructionSet {
+        let ops = &self.ops;
+
+        if ops.is_empty() {
+            return self;
+        }
+
+        // Keep track of a map between jump labels and op indices. Useful to compute op successors.
+        let mut label_to_index: HashMap<Label, usize> = HashMap::default();
+        for (idx, op) in ops.iter().enumerate() {
+            if let Either::Right(ControlFlowOp::Label(op_label)) = op.opcode {
+                label_to_index.insert(op_label, idx);
+            }
+        }
+
+        let mut reachables = vec![false; ops.len()];
+        let mut worklist = vec![0];
+        while let Some(op_idx) = worklist.pop() {
+            assert!(!reachables[op_idx]);
+            reachables[op_idx] = true;
+            let op = &ops[op_idx];
+            for s in &op.successors(op_idx, ops, &label_to_index) {
+                if !reachables[*s] {
+                    worklist.push(*s);
+                }
+            }
+        }
+
+        let reachable_ops = self
+            .ops
+            .into_iter()
+            .enumerate()
+            .filter_map(|(idx, op)| if reachables[idx] { Some(op) } else { None })
+            .collect();
+        self.ops = reachable_ops;
+
+        self
+    }
 }
diff --git a/sway-core/src/asm_generation/fuel/programs/abstract.rs b/sway-core/src/asm_generation/fuel/programs/abstract.rs
index 9f81c767c42..17b6240a95d 100644
--- a/sway-core/src/asm_generation/fuel/programs/abstract.rs
+++ b/sway-core/src/asm_generation/fuel/programs/abstract.rs
@@ -78,7 +78,7 @@ impl AbstractProgram {
             && self.data_section.value_pairs.is_empty()
     }
 
-    /// Adds prologue, globals allocation, before entries, contract method switch, and allocates virtual register
+    /// Adds prologue, globals allocation, before entries, contract method switch, and allocates virtual register.
     pub(crate) fn into_allocated_program(
         mut self,
         fallback_fn: Option<crate::asm_lang::Label>,
@@ -111,21 +111,21 @@ impl AbstractProgram {
             })
             .collect();
 
-        // Gather all functions
+        // Gather all functions.
         let all_functions = self
             .entries
             .into_iter()
             .map(|entry| entry.ops)
             .chain(self.non_entries);
 
-        // optimise and then verify these functions.
+        // Optimize and then verify abstract functions.
         let abstract_functions = all_functions
             .map(|instruction_set| instruction_set.optimize(&self.data_section))
             .map(AbstractInstructionSet::verify)
             .collect::<Result<Vec<AbstractInstructionSet>, CompileError>>()?;
 
         // Allocate the registers for each function.
-        let functions = abstract_functions
+        let allocated_functions = abstract_functions
             .into_iter()
             .map(|abstract_instruction_set| {
                 let allocated = abstract_instruction_set.allocate_registers()?;
@@ -133,7 +133,12 @@ impl AbstractProgram {
             })
             .collect::<Result<Vec<AllocatedAbstractInstructionSet>, CompileError>>()?;
 
-        // XXX need to verify that the stack use for each function is balanced.
+        // Optimize allocated functions.
+        // TODO: Add verification. E.g., verify that the stack use for each function is balanced.
+        let functions = allocated_functions
+            .into_iter()
+            .map(|instruction_set| instruction_set.optimize())
+            .collect::<Vec<AllocatedAbstractInstructionSet>>();
 
         Ok(AllocatedProgram {
             kind: self.kind,
@@ -225,7 +230,7 @@ impl AbstractProgram {
         let entry = self.entries.iter().find(|x| x.name == "__entry").unwrap();
         asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Right(ControlFlowOp::Jump(entry.label)),
-            comment: "jump to abi method selector".into(),
+            comment: "jump to ABI function selector".into(),
             owning_span: None,
         });
     }
@@ -247,7 +252,7 @@ impl AbstractProgram {
         // Build the switch statement for selectors.
         asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Right(ControlFlowOp::Comment),
-            comment: "Begin contract ABI selector switch".into(),
+            comment: "[function selection]: begin contract function selector switch".into(),
             owning_span: None,
         });
 
@@ -261,7 +266,7 @@ impl AbstractProgram {
                     "constant infallible value",
                 ),
             )),
-            comment: "load input function selector".into(),
+            comment: "[function selection]: load input function selector".into(),
             owning_span: None,
         });
 
@@ -283,7 +288,10 @@ impl AbstractProgram {
             // Load the data into a register for comparison.
             asm.ops.push(AllocatedAbstractOp {
                 opcode: Either::Left(AllocatedOpcode::LoadDataId(PROG_SELECTOR_REG, data_label)),
-                comment: format!("load fn selector for comparison {}", entry.name),
+                comment: format!(
+                    "[function selection]: load function {} selector for comparison",
+                    entry.name
+                ),
                 owning_span: None,
             });
 
@@ -294,7 +302,10 @@ impl AbstractProgram {
                     INPUT_SELECTOR_REG,
                     PROG_SELECTOR_REG,
                 )),
-                comment: "function selector comparison".into(),
+                comment: format!(
+                    "[function selection]: compare function {} selector with input selector",
+                    entry.name
+                ),
                 owning_span: None,
             });
 
@@ -302,7 +313,7 @@ impl AbstractProgram {
             asm.ops.push(AllocatedAbstractOp {
                 // If the comparison result is _not_ equal to 0, then it was indeed equal.
                 opcode: Either::Right(ControlFlowOp::JumpIfNotZero(CMP_RESULT_REG, entry.label)),
-                comment: "jump to selected function".into(),
+                comment: "[function selection]: jump to selected contract function".into(),
                 owning_span: None,
             });
         }
@@ -310,7 +321,7 @@ impl AbstractProgram {
         if let Some(fallback_fn) = fallback_fn {
             asm.ops.push(AllocatedAbstractOp {
                 opcode: Either::Right(ControlFlowOp::Call(fallback_fn)),
-                comment: "call fallback function".into(),
+                comment: "[function selection]: call contract fallback function".into(),
                 owning_span: None,
             });
         }
@@ -322,14 +333,15 @@ impl AbstractProgram {
                     value: compiler_constants::MISMATCHED_SELECTOR_REVERT_CODE,
                 },
             )),
-            comment: "special code for mismatched selector".into(),
+            comment: "[function selection]: load revert code for mismatched function selector"
+                .into(),
             owning_span: None,
         });
         asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Left(AllocatedOpcode::RVRT(AllocatedRegister::Constant(
                 ConstantRegister::Scratch,
             ))),
-            comment: "revert if no selectors matched".into(),
+            comment: "[function selection]: revert if no selectors have matched".into(),
             owning_span: None,
         });
     }
@@ -340,7 +352,7 @@ impl AbstractProgram {
             opcode: Either::Left(AllocatedOpcode::CFEI(VirtualImmediate24 {
                 value: len_in_bytes as u32,
             })),
-            comment: "stack space for globals".into(),
+            comment: "allocate stack space for globals".into(),
             owning_span: None,
         });
     }
diff --git a/sway-core/src/asm_generation/fuel/register_allocator.rs b/sway-core/src/asm_generation/fuel/register_allocator.rs
index 9cae883fe26..8e02d2d29fa 100644
--- a/sway-core/src/asm_generation/fuel/register_allocator.rs
+++ b/sway-core/src/asm_generation/fuel/register_allocator.rs
@@ -791,7 +791,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                                 value: offset_bytes,
                             },
                         )),
-                        comment: "Spill/Refill: Set offset".to_string(),
+                        comment: "[spill/refill]: set offset".to_string(),
                         owning_span: None,
                     };
                     inst_list.push(offset_mov_instr);
@@ -801,7 +801,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             VirtualRegister::Constant(ConstantRegister::LocalsBase),
                         )),
-                        comment: "Spill/Refill: Add offset to stack base".to_string(),
+                        comment: "[spill/refill]: add offset to stack base".to_string(),
                         owning_span: None,
                     };
                     inst_list.push(offset_add_instr);
@@ -827,7 +827,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                                 value: offset_upper_12,
                             },
                         )),
-                        comment: "Spill/Refill: Offset computation".to_string(),
+                        comment: "[spill/refill]: compute offset".to_string(),
                         owning_span: None,
                     };
                     inst_list.push(offset_upper_mov_instr);
@@ -837,7 +837,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             VirtualImmediate12 { value: 12 },
                         )),
-                        comment: "Spill/Refill: Offset computation".to_string(),
+                        comment: "[spill/refill]: compute offset".to_string(),
                         owning_span: None,
                     };
                     inst_list.push(offset_upper_shift_instr);
@@ -847,7 +847,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                             VirtualRegister::Constant(ConstantRegister::Scratch),
                             VirtualRegister::Constant(ConstantRegister::LocalsBase),
                         )),
-                        comment: "Spill/Refill: Offset computation".to_string(),
+                        comment: "[spill/refill]: compute offset".to_string(),
                         owning_span: None,
                     };
                     inst_list.push(offset_add_instr);
@@ -876,7 +876,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                                 value: (offset_bytes / 8) as u16,
                             },
                         )),
-                        comment: "Refilling from spill".to_string(),
+                        comment: "[spill/refill]: refill from spill".to_string(),
                         owning_span: None,
                     });
                 } else {
@@ -889,7 +889,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                             // This will be multiplied by 8 by the VM
                             offset_imm_word,
                         )),
-                        comment: "Refilling from spill".to_string(),
+                        comment: "[spill/refill]: refill from spill".to_string(),
                         owning_span: None,
                     };
                     spilled.push(lw);
@@ -914,7 +914,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                                 value: (offset_bytes / 8) as u16,
                             },
                         )),
-                        comment: "Spill".to_string(),
+                        comment: "[spill/refill]: spill".to_string(),
                         owning_span: None,
                     });
                 } else {
@@ -927,7 +927,7 @@ fn spill(ops: &[Op], spills: &FxHashSet<VirtualRegister>) -> Vec<Op> {
                             // This will be multiplied by 8 by the VM
                             offset_imm_word,
                         )),
-                        comment: "Spill".to_string(),
+                        comment: "[spill/refill]: spill".to_string(),
                         owning_span: None,
                     };
                     spilled.push(sw);
diff --git a/sway-core/src/asm_generation/instruction_set.rs b/sway-core/src/asm_generation/instruction_set.rs
index 6e5f007e305..c96c3f69df0 100644
--- a/sway-core/src/asm_generation/instruction_set.rs
+++ b/sway-core/src/asm_generation/instruction_set.rs
@@ -4,15 +4,8 @@ use std::fmt;
 /// An [InstructionSet] is produced by allocating registers on an [AbstractInstructionSet].
 #[derive(Clone)]
 pub enum InstructionSet {
-    Fuel {
-        ops: Vec<AllocatedOp>,
-    },
-    Evm {
-        ops: Vec<etk_asm::ops::AbstractOp>,
-    },
-    MidenVM {
-        ops: Vec<crate::asm_generation::DirectOp>,
-    },
+    Fuel { ops: Vec<AllocatedOp> },
+    Evm { ops: Vec<etk_asm::ops::AbstractOp> },
 }
 
 impl fmt::Display for InstructionSet {
@@ -31,12 +24,6 @@ impl fmt::Display for InstructionSet {
                     .map(|x| format!("{x}"))
                     .collect::<Vec<_>>()
                     .join("\n"),
-                InstructionSet::MidenVM { ops } => {
-                    ops.iter()
-                        .map(|x| format!("{x}"))
-                        .collect::<Vec<_>>()
-                        .join("\n")
-                }
             }
         )
     }
diff --git a/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder.rs b/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder.rs
deleted file mode 100644
index ff0575219a0..00000000000
--- a/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder.rs
+++ /dev/null
@@ -1,704 +0,0 @@
-#![allow(dead_code)]
-use std::{collections::HashMap, sync::Arc};
-mod miden_op;
-use indexmap::IndexMap;
-pub use miden_op::MidenAsmOp;
-
-use crate::{
-    asm_generation::{
-        asm_builder::AsmBuilder,
-        from_ir::StateAccessType,
-        fuel::data_section::DataSection,
-        instruction_set::InstructionSet,
-        miden_vm::miden_vm_asm_builder::miden_op::{MidenStackValue, Push},
-        FinalizedAsm, ProgramKind,
-    },
-    asm_lang::Label,
-    metadata::MetadataManager,
-    BuildConfig,
-};
-
-use sway_error::{
-    error::CompileError,
-    handler::{ErrorEmitted, Handler},
-};
-use sway_ir::{Context, *};
-use sway_types::Span;
-
-pub use miden_op::DirectOp;
-
-#[derive(Default)]
-pub struct MidenVMAsmSection {
-    ops: Vec<miden_core::Operation>,
-}
-
-/// A procedure block is used to define a frequently-used sequence of instructions. A procedure must
-/// start with a proc.<label>.<number of locals> instruction and terminate with an end instruction.
-/// [ref](https://wiki.polygon.technology/docs/miden/user_docs/assembly/code_organization#procedures)
-pub struct Procedure {
-    number_of_locals: u32,
-    ops: Vec<MidenAsmOp>,
-}
-
-#[derive(Default, Copy, Clone)]
-pub struct StackLabel(usize);
-
-#[derive(Default)]
-/// an abstract stack, used to organize instruction code
-pub struct StackManager {
-    idx: StackLabel,
-}
-
-impl StackManager {
-    pub fn insert_value(&mut self) -> StackLabel {
-        let label = self.idx;
-        self.idx.0 += 1;
-        label
-    }
-    pub fn size(&self) -> usize {
-        self.idx.0
-    }
-}
-// will likely want to minimize these names eventually
-// for now, we can use function names for readability
-pub type ProcedureName = String;
-
-pub type ProcedureMap = IndexMap<ProcedureName, Procedure>;
-
-/// MidenVM Asm is built in the following way:
-/// Function bodies are abstracted into [Procedures]
-/// Arguments to functions are evaluated before the exec.proc is issued
-pub struct MidenVMAsmBuilder<'ir, 'eng> {
-    procedure_map: ProcedureMap,
-    buf: Vec<MidenAsmOp>,
-    #[allow(dead_code)]
-    program_kind: ProgramKind,
-    pub(super) func_label_map: HashMap<Function, (Label, Label)>,
-    /// If we are currently compiling a procedure, then ops get inserted to that procedure
-    /// otherwise, we push to the main procedure
-    active_procedure: Option<ProcedureName>,
-
-    // IR context we're compiling.
-    context: &'ir Context<'eng>,
-
-    // Metadata manager for converting metadata to Spans, etc.
-    md_mgr: MetadataManager,
-
-    // Monotonically increasing unique identifier for label generation.
-    label_idx: usize,
-
-    // stack label generator
-    stack_manager: StackManager,
-}
-
-impl std::fmt::Debug for MidenVMAsmBuilder<'_, '_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let ops = self
-            .buf
-            .iter()
-            .map(|x| format!("{x}"))
-            .collect::<Vec<_>>()
-            .join("\n");
-        writeln!(f, "Stack size: {}", self.stack_manager.size())?;
-        write!(f, "{ops}")
-    }
-}
-
-impl MidenVMAsmSection {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn size(&self) -> usize {
-        todo!()
-    }
-}
-
-pub struct MidenVMAsmBuilderResult {
-    pub ops: Vec<miden_op::DirectOp>,
-}
-
-pub type MidenVMAbiResult = ();
-
-impl<'ir, 'eng> AsmBuilder for MidenVMAsmBuilder<'ir, 'eng> {
-    fn compile_function(
-        &mut self,
-        handler: &Handler,
-        function: Function,
-    ) -> Result<(), ErrorEmitted> {
-        self.compile_function(handler, function)
-    }
-
-    fn func_to_labels(&mut self, func: &Function) -> (Label, Label) {
-        self.func_label_map.get(func).cloned().unwrap_or_else(|| {
-            let labels = (self.get_label(), self.get_label());
-            self.func_label_map.insert(*func, labels);
-            labels
-        })
-    }
-
-    fn compile_configurable(&mut self, _config: &ConfigContent) {
-        todo!()
-    }
-
-    fn finalize(
-        self,
-        _handler: &Handler,
-        _build_config: Option<&BuildConfig>,
-        _fallback_fn: Option<Label>,
-    ) -> Result<FinalizedAsm, ErrorEmitted> {
-        // take each procedure and serialize it with the format described [here](https://wiki.polygon.technology/docs/miden/user_docs/assembly/code_organization/#procedures)
-        let mut program = self.finalize_procedure_map();
-        // main fn is a call into one of the procedure_map fns
-        program.push(DirectOp::begin());
-        for op in &self.buf {
-            program.append(&mut self.render_op(op))
-        }
-        program.push(DirectOp::end());
-
-        let final_program = MidenFinalProgram { ops: program };
-        Ok(final_program.finalize())
-    }
-}
-
-#[allow(unused_variables)]
-#[allow(dead_code)]
-impl<'ir, 'eng> MidenVMAsmBuilder<'ir, 'eng> {
-    pub fn new(program_kind: ProgramKind, context: &'ir Context<'eng>) -> Self {
-        MidenVMAsmBuilder {
-            procedure_map: Default::default(),
-            buf: Default::default(),
-            func_label_map: Default::default(),
-            program_kind,
-            context,
-            md_mgr: MetadataManager::default(),
-            label_idx: 0,
-            stack_manager: Default::default(),
-            active_procedure: None,
-        }
-    }
-
-    fn generate_constructor(
-        &self,
-        is_payable: bool,
-        data_size: u32,
-        data_offset: u32,
-    ) -> MidenVMAsmSection {
-        todo!()
-    }
-
-    fn copy_contract_code_to_memory(
-        &self,
-        s: &MidenVMAsmSection,
-        data_size: u32,
-        data_offset: u32,
-    ) {
-        todo!()
-    }
-
-    fn generate_function(&mut self) -> MidenVMAsmSection {
-        todo!()
-    }
-
-    fn finalize_procedure_map(&self) -> Vec<DirectOp> {
-        let mut buf: Vec<DirectOp> = Vec::with_capacity(self.procedure_map.len());
-        for (ref proc_name, proc) in &self.procedure_map {
-            buf.push(DirectOp::procedure_decl(
-                proc_name.to_string(),
-                proc.number_of_locals,
-            ));
-            for op in &proc.ops {
-                buf.append(&mut self.render_op(op))
-            }
-        }
-        buf
-    }
-
-    fn empty_span() -> Span {
-        let msg = "unknown source location";
-        Span::new(Arc::from(msg), 0, msg.len(), None).unwrap()
-    }
-
-    fn get_label(&mut self) -> Label {
-        let next_val = self.label_idx;
-        self.label_idx += 1;
-        Label(self.label_idx)
-    }
-
-    /// compiles some value and ensures it is on the top of the stack
-    fn push_value_to_stack(
-        &mut self,
-        handler: &Handler,
-        value: &Value,
-    ) -> Result<(), ErrorEmitted> {
-        todo!()
-    }
-
-    /// ref: https://wiki.polygon.technology/docs/miden/user_docs/assembly/flow_control#conditional-execution
-    /// TODO:
-    /// Potentially use conditional dropping if the cost of the branches is less than the cost to execute the if
-    /// op
-
-    fn compile_conditional_branch(
-        &mut self,
-        handler: &Handler,
-        cond_value: &Value,
-        true_block: &BranchToWithArgs,
-        false_block: &BranchToWithArgs,
-    ) {
-        // compile the condition, make sure it is at the top of the stack
-        // generate the `if.true`
-        // generate the body
-        // generate the `else`
-        // generate the else block
-        let _ = self.push_value_to_stack(handler, cond_value);
-        self.compile_branch(true_block);
-        self.compile_branch(true_block);
-        // todo need to figure out how to handle the compile results here
-
-        /*
-        self.buf.push(MidenAsmOp::If {
-            condition,
-            true_branch,
-            else_branch,
-        });
-        */
-        todo!()
-    }
-
-    fn compile_branch(&mut self, to_block: &BranchToWithArgs) {
-        todo!()
-        // self.compile_branch_to_phi_value(to_block);
-
-        // let label = self.block_to_label(&to_block.block);
-        // self.cur_bytecode.push(Op::jump_to_label(label));
-    }
-    pub(super) fn compile_call(&mut self, instr_val: &Value, function: &Function, args: &[Value]) {
-        // Assume the arguments have been compiled
-        // We standardize on the arguments being the top N values in the stack
-        // This compilation task simply has to run the procedure
-
-        // The `args` are already on the top of the stack, in the correct order. Load them into local memory
-        // let mut arg_mapping = Vec::new();
-
-        todo!(
-            "Unable to compile fn call {}, need to design function calls.",
-            function.get_name(self.context)
-        )
-    }
-    pub(super) fn compile_instruction(&mut self, handler: &Handler, instr_val: &Value) {
-        if let Some(instruction) = instr_val.get_instruction(self.context) {
-            match &instruction.op {
-                InstOp::AsmBlock(asm, args) => todo!(),
-                InstOp::BitCast(val, ty) => todo!(),
-                InstOp::UnaryOp { op, arg } => {
-                    todo!()
-                }
-                InstOp::BinaryOp { op, arg1, arg2 } => {
-                    todo!()
-                }
-                InstOp::Branch(to_block) => todo!(),
-                InstOp::Call(func, args) => self.compile_call(instr_val, func, args),
-                InstOp::CastPtr(val, ty) => {
-                    todo!()
-                }
-                InstOp::Cmp(pred, lhs_value, rhs_value) => {
-                    todo!()
-                }
-                InstOp::ConditionalBranch {
-                    cond_value,
-                    true_block,
-                    false_block,
-                } => self.compile_conditional_branch(handler, cond_value, true_block, false_block),
-                InstOp::ContractCall {
-                    params,
-                    coins,
-                    asset_id,
-                    gas,
-                    ..
-                } => todo!(),
-                InstOp::FuelVm(fuel_vm_instr) => todo!(),
-                InstOp::GetElemPtr {
-                    base,
-                    elem_ptr_ty,
-                    indices,
-                } => todo!(),
-                InstOp::GetLocal(local_var) => todo!(),
-                InstOp::GetConfig(_, name) => todo!(),
-                InstOp::IntToPtr(val, _) => todo!(),
-                InstOp::Load(src_val) => todo!(),
-                InstOp::MemCopyBytes {
-                    dst_val_ptr,
-                    src_val_ptr,
-                    byte_len,
-                } => todo!(),
-                InstOp::MemCopyVal {
-                    dst_val_ptr,
-                    src_val_ptr,
-                } => todo!(),
-                InstOp::Nop => (),
-                InstOp::PtrToInt(ptr_val, int_ty) => todo!(),
-                InstOp::Ret(ret_val, ty) => self.compile_return(ret_val, ty),
-                InstOp::Store {
-                    dst_val_ptr,
-                    stored_val,
-                } => todo!(),
-            }
-        } else {
-            panic!(
-                "{:?}",
-                CompileError::Internal(
-                    "Value not an instruction.",
-                    self.md_mgr
-                        .val_to_span(self.context, *instr_val)
-                        .unwrap_or_else(Self::empty_span),
-                )
-            )
-        }
-    }
-
-    fn compile_asm_block(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-        asm: &AsmBlock,
-        asm_args: &[AsmArg],
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    fn compile_addr_of(&mut self, instr_val: &Value, arg: &Value) {
-        todo!();
-    }
-
-    fn compile_bitcast(&mut self, instr_val: &Value, bitcast_val: &Value, to_type: &Type) {
-        todo!();
-    }
-
-    fn compile_binary_op(
-        &mut self,
-        instr_val: &Value,
-        op: &BinaryOpKind,
-        arg1: &Value,
-        arg2: &Value,
-    ) {
-        todo!();
-    }
-
-    fn compile_cast_ptr(&mut self, instr_val: &Value, val: &Value, ty: &Type, offs: u64) {
-        todo!();
-    }
-
-    fn compile_cmp(
-        &mut self,
-        instr_val: &Value,
-        pred: &Predicate,
-        lhs_value: &Value,
-        rhs_value: &Value,
-    ) {
-        todo!();
-    }
-
-    fn compile_branch_to_phi_value(&mut self, to_block: &BranchToWithArgs) {
-        todo!();
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn compile_contract_call(
-        &mut self,
-        instr_val: &Value,
-        params: &Value,
-        coins: &Value,
-        asset_id: &Value,
-        gas: &Value,
-    ) {
-        todo!();
-    }
-
-    fn compile_extract_element(
-        &mut self,
-        instr_val: &Value,
-        array: &Value,
-        ty: &Type,
-        index_val: &Value,
-    ) {
-        todo!();
-    }
-
-    fn compile_extract_value(&mut self, instr_val: &Value, aggregate_val: &Value, indices: &[u64]) {
-        todo!();
-    }
-
-    fn compile_get_storage_key(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    fn compile_get_local(&mut self, instr_val: &Value, local_var: &LocalVar) {
-        todo!();
-    }
-
-    fn compile_gtf(&mut self, instr_val: &Value, index: &Value, tx_field_id: u64) {
-        todo!();
-    }
-
-    fn compile_insert_element(
-        &mut self,
-        instr_val: &Value,
-        array: &Value,
-        ty: &Type,
-        value: &Value,
-        index_val: &Value,
-    ) {
-        todo!();
-    }
-
-    fn compile_insert_value(
-        &mut self,
-        instr_val: &Value,
-        aggregate_val: &Value,
-        value: &Value,
-        indices: &[u64],
-    ) {
-        todo!();
-    }
-
-    fn compile_int_to_ptr(&mut self, instr_val: &Value, int_to_ptr_val: &Value) {
-        todo!();
-    }
-
-    fn compile_load(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-        src_val: &Value,
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    fn compile_mem_copy(
-        &mut self,
-        instr_val: &Value,
-        dst_val: &Value,
-        src_val: &Value,
-        byte_len: u64,
-    ) {
-        todo!();
-    }
-
-    fn compile_log(&mut self, instr_val: &Value, log_val: &Value, log_ty: &Type, log_id: &Value) {
-        todo!();
-    }
-
-    fn compile_read_register(&mut self, instr_val: &Value, reg: &sway_ir::Register) {
-        todo!();
-    }
-
-    fn compile_ret_from_entry(&mut self, instr_val: &Value, ret_val: &Value, ret_type: &Type) {
-        todo!();
-    }
-
-    fn compile_revert(&mut self, instr_val: &Value, revert_val: &Value) {
-        todo!();
-    }
-
-    fn compile_smo(
-        &mut self,
-        instr_val: &Value,
-        recipient_and_message: &Value,
-        message_size: &Value,
-        output_index: &Value,
-        coins: &Value,
-    ) {
-        todo!();
-    }
-
-    fn compile_state_access_quad_word(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-        val: &Value,
-        key: &Value,
-        number_of_slots: &Value,
-        access_type: StateAccessType,
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    fn compile_state_load_word(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-        key: &Value,
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    fn compile_state_store_word(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-        store_val: &Value,
-        key: &Value,
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    fn compile_store(
-        &mut self,
-        handler: &Handler,
-        instr_val: &Value,
-        dst_val: &Value,
-        stored_val: &Value,
-    ) -> Result<(), ErrorEmitted> {
-        todo!();
-    }
-
-    pub fn compile_function(
-        &mut self,
-        handler: &Handler,
-        function: Function,
-    ) -> Result<(), ErrorEmitted> {
-        if function.get_name(self.context).to_lowercase() != "main" {
-            self.set_active_procedure(&function);
-        }
-        self.compile_code_block(handler, function.block_iter(self.context));
-        self.end_active_procedure();
-        Ok(())
-    }
-
-    fn compile_code_block(&mut self, handler: &Handler, block: BlockIterator) {
-        for block in block {
-            for instr_val in block.instruction_iter(self.context) {
-                self.compile_instruction(handler, &instr_val);
-            }
-        }
-    }
-
-    pub(super) fn compile_ret_from_call(&mut self, instr_val: &Value, ret_val: &Value) {
-        todo!();
-    }
-
-    /// Compiles a return instruction.
-    /// https://0xpolygonmiden.github.io/miden-vm/design/stack/main.html#operand-stack
-    /// By the end of program execution, exactly 16 items must remain on the stack (again,
-    ///  all of them could be 0's). These items comprise the output of the program.
-
-    /// all we have to do here is make sure the returned value is on top of the stack
-    /// this works in both internal procedure returns and external main returns
-    pub fn compile_return(&mut self, ret_val: &Value, ty: &Type) {
-        self.compile_value_access(ret_val)
-    }
-
-    fn compile_value_access(&mut self, ret_val: &Value) {
-        self.push_op(MidenAsmOp::access_value(*ret_val));
-    }
-
-    fn push_op(&mut self, op: MidenAsmOp) {
-        if let Some(ref proc_name) = self.active_procedure {
-            let res = self.procedure_map.get_mut(proc_name);
-            if let Some(res) = res {
-                res.ops.push(op);
-            } else {
-                unreachable!("It is an invariant that a proc name would be in the mapping already. This is an internal compiler error.")
-            }
-        } else {
-            self.buf.push(op);
-        }
-    }
-
-    fn set_active_procedure(&mut self, function: &Function) {
-        self.procedure_map.insert(
-            function.get_name(self.context).into(),
-            Procedure {
-                number_of_locals: function.num_args(self.context) as u32,
-                ops: Default::default(),
-            },
-        );
-    }
-
-    fn end_active_procedure(&mut self) {
-        self.active_procedure = None;
-    }
-
-    fn render_abstract_op(&self, op: &miden_op::AbstractOp) -> Vec<DirectOp> {
-        use miden_op::AbstractOp::*;
-        match op {
-            AccessValue(val) => {
-                // TODO: configurables, instructions, etc
-                //        todo!("check chained or-else stuff in fuel asm builder")
-                let rendered = val
-                    .get_constant(self.context)
-                    .map(|constant| self.render_constant(constant))
-                    .or_else(|| todo!());
-                if let Some(rendered) = rendered {
-                    rendered
-                } else {
-                    panic!("Not sure what this value is -- isn't a constant or a configurable. {val:?}")
-                }
-            }
-        }
-    }
-
-    fn render_op(&self, op: &MidenAsmOp) -> Vec<DirectOp> {
-        match op {
-            MidenAsmOp::DirectOp(a) => vec![a.clone()],
-            MidenAsmOp::AbstractOp(op) => self.render_abstract_op(op),
-        }
-    }
-
-    /// Pushes a constant to the top of the stack
-    pub(crate) fn render_constant(&self, constant: &Constant) -> Vec<DirectOp> {
-        use sway_ir::ConstantValue::*;
-        match &constant.value {
-            Undef => todo!(),
-            Unit => vec![DirectOp::push(MidenStackValue::Unit)],
-            Bool(b) => vec![DirectOp::push(*b)],
-            Uint(x) => vec![DirectOp::push(*x)],
-            U256(x) => todo!(),
-            B256(_) => todo!(),
-            String(_) => todo!(),
-            Array(_) => todo!(),
-            Struct(_) => todo!(),
-            Reference(_) => todo!(),
-            RawUntypedSlice(_) => todo!(),
-        }
-    }
-}
-
-pub trait ToMidenBytecode {
-    // the midenVM expects assembly in String form
-    fn to_bytecode(&self) -> String;
-}
-
-impl ToMidenBytecode for Vec<DirectOp> {
-    fn to_bytecode(&self) -> String {
-        // TODO nice indentation and stuff
-        self.iter()
-            .map(|x| format!("{x}"))
-            .collect::<Vec<_>>()
-            .join("\n")
-    }
-}
-
-struct MidenFinalProgram {
-    ops: Vec<crate::asm_generation::DirectOp>,
-}
-
-impl MidenFinalProgram {
-    fn finalize(self) -> FinalizedAsm {
-        FinalizedAsm {
-            data_section: DataSection {
-                ..Default::default()
-            },
-            program_section: InstructionSet::MidenVM { ops: self.ops },
-            // should this be a script? :think:
-            program_kind: ProgramKind::Script,
-            entries: vec![],
-            abi: None, /* TODO? */
-        }
-    }
-}
diff --git a/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder/miden_op.rs b/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder/miden_op.rs
deleted file mode 100644
index 870094cfaa1..00000000000
--- a/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder/miden_op.rs
+++ /dev/null
@@ -1,394 +0,0 @@
-use std::fmt::Display;
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum AbstractOp {
-    // corresponds to "Ensure this value is on top of the stack"
-    AccessValue(sway_ir::Value),
-}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum DirectOp {
-    Exec(super::ProcedureName),
-
-    ProcedureDecl {
-        name: super::ProcedureName,
-        number_of_locals: u32,
-    },
-    Begin,
-    End,
-    If {
-        condition: Vec<MidenAsmOp>,
-        true_branch: Vec<MidenAsmOp>,
-        else_branch: Vec<MidenAsmOp>,
-    },
-    Push(MidenStackValue),
-}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum MidenStackValue {
-    Unit,
-    Number(u64),
-    Bool(bool),
-}
-
-impl Display for MidenStackValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                MidenStackValue::Unit => "0".into(),
-                MidenStackValue::Number(x) => x.to_string(),
-                MidenStackValue::Bool(b) => if *b { "1" } else { "0" }.into(),
-            },
-        )
-    }
-}
-impl From<bool> for MidenStackValue {
-    fn from(value: bool) -> Self {
-        MidenStackValue::Bool(value)
-    }
-}
-
-impl From<u64> for MidenStackValue {
-    fn from(value: u64) -> Self {
-        MidenStackValue::Number(value)
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum MidenAsmOp {
-    DirectOp(DirectOp),
-    /// This is an abstract Op. Meaning, this doesn't correspond to an
-    /// individual MidenVM asm op.     
-    AbstractOp(AbstractOp),
-    /*
-    Assert,
-    AssertEq,
-    Assertz,
-    Add,
-    AddImm(Felt),
-    Sub,
-    SubImm(Felt),
-    Mul,
-    MulImm(Felt),
-    Div,
-    DivImm(Felt),
-    Neg,
-    Inv,
-    Pow2,
-    Exp,
-    ExpImm(Felt),
-    ExpBitLength(u8),
-    Not,
-    And,
-    Or,
-    Xor,
-    Eq,
-    EqImm(Felt),
-    Neq,
-    NeqImm(Felt),
-    Eqw,
-    Lt,
-    Lte,
-    Gt,
-    Gte,
-
-    // ----- u32 manipulation ---------------------------------------------------------------
-    U32Test,
-    U32TestW,
-    U32Assert,
-    U32Assert2,
-    U32AssertW,
-    U32Split,
-    U32Cast,
-    U32CheckedAdd,
-    U32CheckedAddImm(u32),
-    U32WrappingAdd,
-    U32WrappingAddImm(u32),
-    U32OverflowingAdd,
-    U32OverflowingAddImm(u32),
-    U32OverflowingAdd3,
-    U32WrappingAdd3,
-    U32CheckedSub,
-    U32CheckedSubImm(u32),
-    U32WrappingSub,
-    U32WrappingSubImm(u32),
-    U32OverflowingSub,
-    U32OverflowingSubImm(u32),
-    U32CheckedMul,
-    U32CheckedMulImm(u32),
-    U32WrappingMul,
-    U32WrappingMulImm(u32),
-    U32OverflowingMul,
-    U32OverflowingMulImm(u32),
-    U32OverflowingMadd,
-    U32WrappingMadd,
-    U32CheckedDiv,
-    U32CheckedDivImm(u32),
-    U32UncheckedDiv,
-    U32UncheckedDivImm(u32),
-    U32CheckedMod,
-    U32CheckedModImm(u32),
-    U32UncheckedMod,
-    U32UncheckedModImm(u32),
-    U32CheckedDivMod,
-    U32CheckedDivModImm(u32),
-    U32UncheckedDivMod,
-    U32UncheckedDivModImm(u32),
-    U32CheckedAnd,
-    U32CheckedOr,
-    U32CheckedXor,
-    U32CheckedNot,
-    U32CheckedShr,
-    U32CheckedShrImm(u8),
-    U32UncheckedShr,
-    U32UncheckedShrImm(u8),
-    U32CheckedShl,
-    U32CheckedShlImm(u8),
-    U32UncheckedShl,
-    U32UncheckedShlImm(u8),
-    U32CheckedRotr,
-    U32CheckedRotrImm(u8),
-    U32UncheckedRotr,
-    U32UncheckedRotrImm(u8),
-    U32CheckedRotl,
-    U32CheckedRotlImm(u8),
-    U32UncheckedRotl,
-    U32UncheckedRotlImm(u8),
-    U32CheckedEq,
-    U32CheckedEqImm(u32),
-    U32CheckedNeq,
-    U32CheckedNeqImm(u32),
-    U32CheckedLt,
-    U32UncheckedLt,
-    U32CheckedLte,
-    U32UncheckedLte,
-    U32CheckedGt,
-    U32UncheckedGt,
-    U32CheckedGte,
-    U32UncheckedGte,
-    U32CheckedMin,
-    U32UncheckedMin,
-    U32CheckedMax,
-    U32UncheckedMax,
-
-    // ----- stack manipulation ---------------------------------------------------------------
-    Drop,
-    DropW,
-    PadW,
-    Dup0,
-    Dup1,
-    Dup2,
-    Dup3,
-    Dup4,
-    Dup5,
-    Dup6,
-    Dup7,
-    Dup8,
-    Dup9,
-    Dup10,
-    Dup11,
-    Dup12,
-    Dup13,
-    Dup14,
-    Dup15,
-    DupW0,
-    DupW1,
-    DupW2,
-    DupW3,
-    Swap1,
-    Swap2,
-    Swap3,
-    Swap4,
-    Swap5,
-    Swap6,
-    Swap7,
-    Swap8,
-    Swap9,
-    Swap10,
-    Swap11,
-    Swap12,
-    Swap13,
-    Swap14,
-    Swap15,
-    SwapW1,
-    SwapW2,
-    SwapW3,
-    SwapDw,
-    MovUp2,
-    MovUp3,
-    MovUp4,
-    MovUp5,
-    MovUp6,
-    MovUp7,
-    MovUp8,
-    MovUp9,
-    MovUp10,
-    MovUp11,
-    MovUp12,
-    MovUp13,
-    MovUp14,
-    MovUp15,
-    MovUpW2,
-    MovUpW3,
-    MovDn2,
-    MovDn3,
-    MovDn4,
-    MovDn5,
-    MovDn6,
-    MovDn7,
-    MovDn8,
-    MovDn9,
-    MovDn10,
-    MovDn11,
-    MovDn12,
-    MovDn13,
-    MovDn14,
-    MovDn15,
-    MovDnW2,
-    MovDnW3,
-    CSwap,
-    CSwapW,
-    CDrop,
-    CDropW,
-
-    // ----- input / output operations --------------------------------------------------------
-    PushConstants(Vec<Felt>),
-    Locaddr(u16),
-    Sdepth,
-    Caller,
-
-    MemLoad,
-    MemLoadImm(u32),
-    MemLoadW,
-    MemLoadWImm(u32),
-    LocLoad(u16),
-    LocLoadW(u16),
-
-    MemStore,
-    MemStoreImm(u32),
-    LocStore(u16),
-    MemStoreW,
-    MemStoreWImm(u32),
-    LocStoreW(u16),
-
-    MemStream,
-    AdvPipe,
-
-    AdvPush(u8),
-    AdvLoadW,
-
-    AdvU64Div,
-    AdvKeyval,
-    AdvMem(u32, u32),
-
-    // ----- cryptographic operations ---------------------------------------------------------
-    RpHash,
-    RpPerm,
-    MTreeGet,
-    MTreeSet,
-    MTreeCwm,
-
-    // ----- exec / call ----------------------------------------------------------------------
-    ExecLocal(u16),
-    ExecImported(ProcedureId),
-    CallLocal(u16),
-    CallImported(ProcedureId),
-    SysCall(ProcedureId),
-    */
-}
-
-impl DirectOp {
-    pub(crate) fn begin() -> DirectOp {
-        DirectOp::Begin
-    }
-
-    pub(crate) fn end() -> DirectOp {
-        DirectOp::End
-    }
-    pub(crate) fn procedure_decl(name: String, number_of_locals: u32) -> DirectOp {
-        DirectOp::ProcedureDecl {
-            name,
-            number_of_locals,
-        }
-    }
-}
-impl<T> Push<T> for DirectOp
-where
-    T: Into<MidenStackValue>,
-{
-    fn push(val: T) -> Self {
-        let num = val.into();
-        DirectOp::Push(num)
-    }
-}
-
-pub trait Push<T> {
-    fn push(val: T) -> Self;
-}
-
-impl MidenAsmOp {
-    pub(crate) fn access_value(value: sway_ir::Value) -> MidenAsmOp {
-        MidenAsmOp::AbstractOp(AbstractOp::AccessValue(value))
-    }
-
-    pub(crate) fn procedure_decl(name: String, number_of_locals: u32) -> MidenAsmOp {
-        MidenAsmOp::DirectOp(DirectOp::procedure_decl(name, number_of_locals))
-    }
-}
-
-impl Display for DirectOp {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use DirectOp::*;
-        f.write_str(&match self {
-            Begin => "begin".into(),
-            End => "end".into(),
-            Exec(name) => format!("exec.{name}"),
-            If {
-                condition: _,
-                true_branch,
-                else_branch,
-            } => format!(
-                "if.true\n{}{}",
-                indented(true_branch),
-                if else_branch.is_empty() {
-                    "".into()
-                } else {
-                    format!("else\n{}\nend", indented(else_branch))
-                }
-            ),
-
-            ProcedureDecl {
-                name,
-                number_of_locals,
-            } => format!("proc.{name}.{number_of_locals}"),
-            Push(val) => format!("push.{val}"),
-        })
-    }
-}
-
-impl Display for AbstractOp {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use AbstractOp::*;
-        f.write_str(&match self {
-            AccessValue(ref v) => format!("~access {v:?}"),
-        })
-    }
-}
-impl Display for MidenAsmOp {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use MidenAsmOp::*;
-        let text = match self {
-            DirectOp(op) => format!("{op}"),
-            AbstractOp(op) => format!("{op}"),
-        };
-        f.write_str(&text)
-    }
-}
-
-/// indents some ops by 1 tab
-fn indented(raw: &[MidenAsmOp]) -> String {
-    let ops = raw.iter().map(|x| x.to_string()).collect::<Vec<_>>();
-    ops.join("\n\t")
-}
diff --git a/sway-core/src/asm_generation/miden_vm/mod.rs b/sway-core/src/asm_generation/miden_vm/mod.rs
deleted file mode 100644
index 53e83db203a..00000000000
--- a/sway-core/src/asm_generation/miden_vm/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-mod miden_vm_asm_builder;
-pub use miden_vm_asm_builder::*;
diff --git a/sway-core/src/asm_generation/mod.rs b/sway-core/src/asm_generation/mod.rs
index 3e2a78bfda5..2cd0e7d0605 100644
--- a/sway-core/src/asm_generation/mod.rs
+++ b/sway-core/src/asm_generation/mod.rs
@@ -3,8 +3,6 @@ pub use abi::*;
 pub mod asm_builder;
 pub mod evm;
 pub use evm::*;
-mod miden_vm;
-pub use miden_vm::*;
 pub mod from_ir;
 pub mod fuel;
 pub mod instruction_set;
diff --git a/sway-core/src/asm_lang/allocated_ops.rs b/sway-core/src/asm_lang/allocated_ops.rs
index 3164e2171e8..b78ba37b2db 100644
--- a/sway-core/src/asm_lang/allocated_ops.rs
+++ b/sway-core/src/asm_lang/allocated_ops.rs
@@ -50,6 +50,10 @@ impl AllocatedRegister {
             AllocatedRegister::Constant(constant) => constant.to_reg_id(),
         }
     }
+
+    pub fn is_zero(&self) -> bool {
+        matches!(self, Self::Constant(ConstantRegister::Zero))
+    }
 }
 
 /// This enum is unfortunately a redundancy of the [fuel_asm::Opcode] and [crate::VirtualOp] enums. This variant, however,
@@ -110,6 +114,12 @@ pub(crate) enum AllocatedOpcode {
         AllocatedRegister,
         VirtualImmediate06,
     ),
+    WQMD(
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+    ),
     WQCM(
         AllocatedRegister,
         AllocatedRegister,
@@ -122,6 +132,12 @@ pub(crate) enum AllocatedOpcode {
         AllocatedRegister,
         AllocatedRegister,
     ),
+    WQMM(
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+    ),
 
     /* Control Flow Instructions */
     JMP(AllocatedRegister),
@@ -180,7 +196,19 @@ pub(crate) enum AllocatedOpcode {
     ),
     CROO(AllocatedRegister, AllocatedRegister),
     CSIZ(AllocatedRegister, AllocatedRegister),
-    LDC(AllocatedRegister, AllocatedRegister, AllocatedRegister),
+    BSIZ(AllocatedRegister, AllocatedRegister),
+    LDC(
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+        VirtualImmediate06,
+    ),
+    BLDD(
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+    ),
     LOG(
         AllocatedRegister,
         AllocatedRegister,
@@ -229,7 +257,12 @@ pub(crate) enum AllocatedOpcode {
     /* Cryptographic Instructions */
     ECK1(AllocatedRegister, AllocatedRegister, AllocatedRegister),
     ECR1(AllocatedRegister, AllocatedRegister, AllocatedRegister),
-    ED19(AllocatedRegister, AllocatedRegister, AllocatedRegister),
+    ED19(
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+    ),
     K256(AllocatedRegister, AllocatedRegister, AllocatedRegister),
     S256(AllocatedRegister, AllocatedRegister, AllocatedRegister),
 
@@ -286,8 +319,10 @@ impl AllocatedOpcode {
             WQOP(_, _, _, _) => vec![],
             WQML(_, _, _, _) => vec![],
             WQDV(_, _, _, _) => vec![],
+            WQMD(_, _, _, _) => vec![],
             WQCM(r1, _, _, _) => vec![r1],
             WQAM(_, _, _, _) => vec![],
+            WQMM(_, _, _, _) => vec![],
 
             /* Control Flow Instructions */
             JMP(_r1) => vec![],
@@ -330,7 +365,9 @@ impl AllocatedOpcode {
             CCP(_r1, _r2, _r3, _r4) => vec![],
             CROO(_r1, _r2) => vec![],
             CSIZ(r1, _r2) => vec![r1],
-            LDC(_r1, _r2, _r3) => vec![],
+            BSIZ(r1, _r2) => vec![r1],
+            LDC(_r1, _r2, _r3, _i0) => vec![],
+            BLDD(_r1, _r2, _r3, _r4) => vec![],
             LOG(_r1, _r2, _r3, _r4) => vec![],
             LOGD(_r1, _r2, _r3, _r4) => vec![],
             MINT(_r1, _r2) => vec![],
@@ -349,7 +386,7 @@ impl AllocatedOpcode {
             /* Cryptographic Instructions */
             ECK1(_r1, _r2, _r3) => vec![],
             ECR1(_r1, _r2, _r3) => vec![],
-            ED19(_r1, _r2, _r3) => vec![],
+            ED19(_r1, _r2, _r3, _r4) => vec![],
             K256(_r1, _r2, _r3) => vec![],
             S256(_r1, _r2, _r3) => vec![],
 
@@ -409,8 +446,10 @@ impl fmt::Display for AllocatedOpcode {
             WQOP(a, b, c, d) => write!(fmtr, "wqop {a} {b} {c} {d}"),
             WQML(a, b, c, d) => write!(fmtr, "wqml {a} {b} {c} {d}"),
             WQDV(a, b, c, d) => write!(fmtr, "wqdv {a} {b} {c} {d}"),
+            WQMD(a, b, c, d) => write!(fmtr, "wqmd {a} {b} {c} {d}"),
             WQCM(a, b, c, d) => write!(fmtr, "wqcm {a} {b} {c} {d}"),
             WQAM(a, b, c, d) => write!(fmtr, "wqam {a} {b} {c} {d}"),
+            WQMM(a, b, c, d) => write!(fmtr, "wqmm {a} {b} {c} {d}"),
 
             /* Control Flow Instructions */
             JMP(a) => write!(fmtr, "jmp {a}"),
@@ -454,7 +493,9 @@ impl fmt::Display for AllocatedOpcode {
             CCP(a, b, c, d) => write!(fmtr, "ccp  {a} {b} {c} {d}"),
             CROO(a, b) => write!(fmtr, "croo {a} {b}"),
             CSIZ(a, b) => write!(fmtr, "csiz {a} {b}"),
-            LDC(a, b, c) => write!(fmtr, "ldc  {a} {b} {c}"),
+            BSIZ(a, b) => write!(fmtr, "bsiz {a} {b}"),
+            LDC(a, b, c, d) => write!(fmtr, "ldc  {a} {b} {c} {d}"),
+            BLDD(a, b, c, d) => write!(fmtr, "bldd {a} {b} {c} {d}"),
             LOG(a, b, c, d) => write!(fmtr, "log  {a} {b} {c} {d}"),
             LOGD(a, b, c, d) => write!(fmtr, "logd {a} {b} {c} {d}"),
             MINT(a, b) => write!(fmtr, "mint {a} {b}"),
@@ -473,7 +514,7 @@ impl fmt::Display for AllocatedOpcode {
             /* Cryptographic Instructions */
             ECK1(a, b, c) => write!(fmtr, "eck1  {a} {b} {c}"),
             ECR1(a, b, c) => write!(fmtr, "ecr1  {a} {b} {c}"),
-            ED19(a, b, c) => write!(fmtr, "ed19  {a} {b} {c}"),
+            ED19(a, b, c, d) => write!(fmtr, "ed19  {a} {b} {c} {d}"),
             K256(a, b, c) => write!(fmtr, "k256 {a} {b} {c}"),
             S256(a, b, c) => write!(fmtr, "s256 {a} {b} {c}"),
 
@@ -573,12 +614,18 @@ impl AllocatedOp {
             WQDV(a, b, c, d) => {
                 op::WQDV::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.value.into()).into()
             }
+            WQMD(a, b, c, d) => {
+                op::WQMD::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
+            }
             WQCM(a, b, c, d) => {
                 op::WQCM::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.value.into()).into()
             }
             WQAM(a, b, c, d) => {
                 op::WQAM::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
             }
+            WQMM(a, b, c, d) => {
+                op::WQMM::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
+            }
 
             /* Control Flow Instructions */
             JMP(a) => op::JMP::new(a.to_reg_id()).into(),
@@ -630,7 +677,13 @@ impl AllocatedOp {
             }
             CROO(a, b) => op::CROO::new(a.to_reg_id(), b.to_reg_id()).into(),
             CSIZ(a, b) => op::CSIZ::new(a.to_reg_id(), b.to_reg_id()).into(),
-            LDC(a, b, c) => op::LDC::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id()).into(),
+            BSIZ(a, b) => op::BSIZ::new(a.to_reg_id(), b.to_reg_id()).into(),
+            LDC(a, b, c, d) => {
+                op::LDC::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.value.into()).into()
+            }
+            BLDD(a, b, c, d) => {
+                op::BLDD::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
+            }
             LOG(a, b, c, d) => {
                 op::LOG::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
             }
@@ -661,7 +714,9 @@ impl AllocatedOp {
             /* Cryptographic Instructions */
             ECK1(a, b, c) => op::ECK1::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id()).into(),
             ECR1(a, b, c) => op::ECR1::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id()).into(),
-            ED19(a, b, c) => op::ED19::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id()).into(),
+            ED19(a, b, c, d) => {
+                op::ED19::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
+            }
             K256(a, b, c) => op::K256::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id()).into(),
             S256(a, b, c) => op::S256::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id()).into(),
 
diff --git a/sway-core/src/asm_lang/mod.rs b/sway-core/src/asm_lang/mod.rs
index afe223f68c3..5e1bcaded52 100644
--- a/sway-core/src/asm_lang/mod.rs
+++ b/sway-core/src/asm_lang/mod.rs
@@ -37,6 +37,31 @@ use std::{
 /// The column where the ; for comments starts
 const COMMENT_START_COLUMN: usize = 40;
 
+fn fmt_opcode_and_comment(
+    opcode: String,
+    comment: &str,
+    fmtr: &mut fmt::Formatter<'_>,
+) -> fmt::Result {
+    // We want the comment to be at the `COMMENT_START_COLUMN` offset to the right,
+    // to not interfere with the ASM but to be aligned.
+    // Some operations like, e.g., data section offset, can span multiple lines.
+    // In that case, we put the comment at the end of the last line, aligned.
+    let mut op_and_comment = opcode;
+    if !comment.is_empty() {
+        let mut op_length = match op_and_comment.rfind('\n') {
+            Some(new_line_index) => op_and_comment.len() - new_line_index - 1,
+            None => op_and_comment.len(),
+        };
+        while op_length < COMMENT_START_COLUMN {
+            op_and_comment.push(' ');
+            op_length += 1;
+        }
+        write!(op_and_comment, "; {}", comment)?;
+    }
+
+    write!(fmtr, "{op_and_comment}")
+}
+
 impl From<&AsmRegister> for VirtualRegister {
     fn from(o: &AsmRegister) -> Self {
         VirtualRegister::Virtual(o.name.clone())
@@ -46,7 +71,25 @@ impl From<&AsmRegister> for VirtualRegister {
 #[derive(Debug, Clone)]
 pub(crate) struct Op {
     pub(crate) opcode: Either<VirtualOp, OrganizationalOp>,
-    /// A descriptive comment for ASM readability
+    /// A descriptive comment for ASM readability.
+    ///
+    /// Comments are a part of the compiler output and meant to
+    /// help both Sway developers interested in the generated ASM
+    /// and the Sway compiler developers.
+    ///
+    /// Comments follow these guidelines:
+    ///   - they start with an imperative verb. E.g.: "allocate" and not "allocating".
+    ///   - they start with a lowercase letter. E.g.: "allocate" and not "Allocate".
+    ///   - they do not end in punctuation. E.g.: "store value" and not "store value.".
+    ///   - they use full words. E.g.: "load return address" and not "load reta" or "load return addr".
+    ///   - abbreviations are written in upper-case. E.g.: "ABI" and not "abi".
+    ///   - names (e.g., function, argument, etc.) are written without quotes. E.g. "main" and not "'main'".
+    ///   - assembly operations are written in lowercase. E.g.: "move" and not "MOVE".
+    ///   - they are short and concise.
+    ///   - if an operation is a part of a logical group of operations, start the comment
+    ///     by a descriptive group name enclosed in square brackets and followed by colon.
+    ///     The remaining part of the comment follows the above guidelines. E.g.:
+    ///     "[bitcast to bool]: convert value to inverted boolean".
     pub(crate) comment: String,
     pub(crate) owning_span: Option<Span>,
 }
@@ -54,7 +97,9 @@ pub(crate) struct Op {
 #[derive(Clone, Debug)]
 pub(crate) struct AllocatedAbstractOp {
     pub(crate) opcode: Either<AllocatedOpcode, ControlFlowOp<AllocatedRegister>>,
-    /// A descriptive comment for ASM readability
+    /// A descriptive comment for ASM readability.
+    ///
+    /// For writing guidelines, see [Op::comment].
     pub(crate) comment: String,
     pub(crate) owning_span: Option<Span>,
 }
@@ -62,7 +107,9 @@ pub(crate) struct AllocatedAbstractOp {
 #[derive(Clone, Debug)]
 pub(crate) struct RealizedOp {
     pub(crate) opcode: AllocatedOpcode,
-    /// A descriptive comment for ASM readability
+    /// A descriptive comment for ASM readability.
+    ///
+    /// For writing guidelines, see [Op::comment].
     pub(crate) comment: String,
     pub(crate) owning_span: Option<Span>,
 }
@@ -211,7 +258,7 @@ impl Op {
         }
     }
 
-    /// Jumps to [Label] `label`  if the given [VirtualRegister] `reg0` is not equal to zero.
+    /// Jumps to [Label] `label` if the given [VirtualRegister] `reg0` is not equal to zero.
     pub(crate) fn jump_if_not_zero(reg0: VirtualRegister, label: Label) -> Self {
         Op {
             opcode: Either::Right(OrganizationalOp::JumpIfNotZero(reg0, label)),
@@ -220,6 +267,19 @@ impl Op {
         }
     }
 
+    /// Jumps to [Label] `label` if the given [VirtualRegister] `reg0` is not equal to zero.
+    pub(crate) fn jump_if_not_zero_comment(
+        reg0: VirtualRegister,
+        label: Label,
+        comment: impl Into<String>,
+    ) -> Self {
+        Op {
+            opcode: Either::Right(OrganizationalOp::JumpIfNotZero(reg0, label)),
+            comment: comment.into(),
+            owning_span: None,
+        }
+    }
+
     /// Dynamically jumps to a register value.
     pub(crate) fn jump_to_register(
         reg: VirtualRegister,
@@ -355,6 +415,34 @@ impl Op {
                 let (r1, r2, imm) = two_regs_imm_12(handler, args, immediate, whole_op_span)?;
                 VirtualOp::SUBI(r1, r2, imm)
             }
+            "wqcm" => {
+                let (r1, r2, r3, imm) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQCM(r1, r2, r3, imm)
+            }
+            "wqop" => {
+                let (r1, r2, r3, imm) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQOP(r1, r2, r3, imm)
+            }
+            "wqml" => {
+                let (r1, r2, r3, imm) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQML(r1, r2, r3, imm)
+            }
+            "wqdv" => {
+                let (r1, r2, r3, imm) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQDV(r1, r2, r3, imm)
+            }
+            "wqmd" => {
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQMD(r1, r2, r3, r4)
+            }
+            "wqam" => {
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQAM(r1, r2, r3, r4)
+            }
+            "wqmm" => {
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::WQMM(r1, r2, r3, r4)
+            }
             "xor" => {
                 let (r1, r2, r3) = three_regs(handler, args, immediate, whole_op_span)?;
                 VirtualOp::XOR(r1, r2, r3)
@@ -485,10 +573,13 @@ impl Op {
                 let (r1, r2) = two_regs(handler, args, immediate, whole_op_span)?;
                 VirtualOp::CSIZ(r1, r2)
             }
-
+            "bsiz" => {
+                let (r1, r2) = two_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::BSIZ(r1, r2)
+            }
             "ldc" => {
-                let (r1, r2, r3) = three_regs(handler, args, immediate, whole_op_span)?;
-                VirtualOp::LDC(r1, r2, r3)
+                let (r1, r2, r3, i0) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
+                VirtualOp::LDC(r1, r2, r3, i0)
             }
             "log" => {
                 let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
@@ -557,8 +648,8 @@ impl Op {
                 VirtualOp::ECR1(r1, r2, r3)
             }
             "ed19" => {
-                let (r1, r2, r3) = three_regs(handler, args, immediate, whole_op_span)?;
-                VirtualOp::ED19(r1, r2, r3)
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::ED19(r1, r2, r3, r4)
             }
             "k256" => {
                 let (r1, r2, r3) = three_regs(handler, args, immediate, whole_op_span)?;
@@ -981,19 +1072,68 @@ fn two_regs_imm_12(
     Ok((reg.clone(), reg2.clone(), imm))
 }
 
-impl fmt::Display for Op {
-    fn fmt(&self, fmtr: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // We want the comment to always be 40 characters offset to the right to not interfere with
-        // the ASM but to be aligned.
-        let mut op_and_comment = self.opcode.to_string();
-        if !self.comment.is_empty() {
-            while op_and_comment.len() < COMMENT_START_COLUMN {
-                op_and_comment.push(' ');
-            }
-            write!(op_and_comment, "; {}", self.comment)?;
+fn three_regs_imm_06(
+    handler: &Handler,
+    args: &[VirtualRegister],
+    immediate: &Option<Ident>,
+    whole_op_span: Span,
+) -> Result<
+    (
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualImmediate06,
+    ),
+    ErrorEmitted,
+> {
+    if args.len() > 3 {
+        handler.emit_err(CompileError::IncorrectNumberOfAsmRegisters {
+            span: whole_op_span.clone(),
+            expected: 3,
+            received: args.len(),
+        });
+    }
+    let (reg, reg2, reg3) = match (args.first(), args.get(1), args.get(2)) {
+        (Some(reg), Some(reg2), Some(reg3)) => (reg, reg2, reg3),
+        _ => {
+            return Err(
+                handler.emit_err(CompileError::IncorrectNumberOfAsmRegisters {
+                    span: whole_op_span,
+                    expected: 3,
+                    received: args.len(),
+                }),
+            );
         }
+    };
+    let (imm, imm_span): (u64, _) = match immediate {
+        None => {
+            return Err(handler.emit_err(CompileError::MissingImmediate {
+                span: whole_op_span,
+            }));
+        }
+        Some(i) => match i.as_str()[1..].parse() {
+            Ok(o) => (o, i.span()),
+            Err(_) => {
+                return Err(
+                    handler.emit_err(CompileError::InvalidImmediateValue { span: i.span() })
+                );
+            }
+        },
+    };
+
+    let imm = match VirtualImmediate06::new(imm, imm_span) {
+        Ok(o) => o,
+        Err(e) => {
+            return Err(handler.emit_err(e));
+        }
+    };
 
-        write!(fmtr, "{op_and_comment}")
+    Ok((reg.clone(), reg2.clone(), reg3.clone(), imm))
+}
+
+impl fmt::Display for Op {
+    fn fmt(&self, fmtr: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt_opcode_and_comment(self.opcode.to_string(), &self.comment, fmtr)
     }
 }
 
@@ -1036,8 +1176,10 @@ impl fmt::Display for VirtualOp {
             WQOP(a, b, c, d) => write!(fmtr, "wqop {a} {b} {c} {d}"),
             WQML(a, b, c, d) => write!(fmtr, "wqml {a} {b} {c} {d}"),
             WQDV(a, b, c, d) => write!(fmtr, "wqdv {a} {b} {c} {d}"),
+            WQMD(a, b, c, d) => write!(fmtr, "wqmd {a} {b} {c} {d}"),
             WQCM(a, b, c, d) => write!(fmtr, "wqcm {a} {b} {c} {d}"),
             WQAM(a, b, c, d) => write!(fmtr, "wqam {a} {b} {c} {d}"),
+            WQMM(a, b, c, d) => write!(fmtr, "wqmm {a} {b} {c} {d}"),
 
             /* Control Flow Instructions */
             JMP(a) => write!(fmtr, "jmp {a}"),
@@ -1073,7 +1215,9 @@ impl fmt::Display for VirtualOp {
             CCP(a, b, c, d) => write!(fmtr, "ccp {a} {b} {c} {d}"),
             CROO(a, b) => write!(fmtr, "croo {a} {b}"),
             CSIZ(a, b) => write!(fmtr, "csiz {a} {b}"),
-            LDC(a, b, c) => write!(fmtr, "ldc {a} {b} {c}"),
+            BSIZ(a, b) => write!(fmtr, "bsiz {a} {b}"),
+            LDC(a, b, c, d) => write!(fmtr, "ldc {a} {b} {c} {d}"),
+            BLDD(a, b, c, d) => write!(fmtr, "bldd {a} {b} {c} {d}"),
             LOG(a, b, c, d) => write!(fmtr, "log {a} {b} {c} {d}"),
             LOGD(a, b, c, d) => write!(fmtr, "logd {a} {b} {c} {d}"),
             MINT(a, b) => write!(fmtr, "mint {a} {b}"),
@@ -1092,7 +1236,7 @@ impl fmt::Display for VirtualOp {
             /* Cryptographic Instructions */
             ECK1(a, b, c) => write!(fmtr, "eck1 {a} {b} {c}"),
             ECR1(a, b, c) => write!(fmtr, "ecr1 {a} {b} {c}"),
-            ED19(a, b, c) => write!(fmtr, "ed19 {a} {b} {c}"),
+            ED19(a, b, c, d) => write!(fmtr, "ed19 {a} {b} {c} {d}"),
             K256(a, b, c) => write!(fmtr, "k256 {a} {b} {c}"),
             S256(a, b, c) => write!(fmtr, "s256 {a} {b} {c}"),
 
@@ -1113,17 +1257,7 @@ impl fmt::Display for VirtualOp {
 
 impl fmt::Display for AllocatedAbstractOp {
     fn fmt(&self, fmtr: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // We want the comment to always be 40 characters offset to the right to not interfere with
-        // the ASM but to be aligned.
-        let mut op_and_comment = self.opcode.to_string();
-        if !self.comment.is_empty() {
-            while op_and_comment.len() < COMMENT_START_COLUMN {
-                op_and_comment.push(' ');
-            }
-            write!(op_and_comment, "; {}", self.comment)?;
-        }
-
-        write!(fmtr, "{op_and_comment}")
+        fmt_opcode_and_comment(self.opcode.to_string(), &self.comment, fmtr)
     }
 }
 
diff --git a/sway-core/src/asm_lang/virtual_ops.rs b/sway-core/src/asm_lang/virtual_ops.rs
index 3a636083c35..ffe3509b7cd 100644
--- a/sway-core/src/asm_lang/virtual_ops.rs
+++ b/sway-core/src/asm_lang/virtual_ops.rs
@@ -75,6 +75,12 @@ pub(crate) enum VirtualOp {
         VirtualRegister,
         VirtualImmediate06,
     ),
+    WQMD(
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+    ),
     WQCM(
         VirtualRegister,
         VirtualRegister,
@@ -87,6 +93,12 @@ pub(crate) enum VirtualOp {
         VirtualRegister,
         VirtualRegister,
     ),
+    WQMM(
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+    ),
 
     /* Control Flow Instructions */
     JMP(VirtualRegister),
@@ -137,7 +149,19 @@ pub(crate) enum VirtualOp {
     ),
     CROO(VirtualRegister, VirtualRegister),
     CSIZ(VirtualRegister, VirtualRegister),
-    LDC(VirtualRegister, VirtualRegister, VirtualRegister),
+    BSIZ(VirtualRegister, VirtualRegister),
+    LDC(
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualImmediate06,
+    ),
+    BLDD(
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+    ),
     LOG(
         VirtualRegister,
         VirtualRegister,
@@ -186,7 +210,12 @@ pub(crate) enum VirtualOp {
     /* Cryptographic Instructions */
     ECK1(VirtualRegister, VirtualRegister, VirtualRegister),
     ECR1(VirtualRegister, VirtualRegister, VirtualRegister),
-    ED19(VirtualRegister, VirtualRegister, VirtualRegister),
+    ED19(
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+    ),
     K256(VirtualRegister, VirtualRegister, VirtualRegister),
     S256(VirtualRegister, VirtualRegister, VirtualRegister),
 
@@ -246,8 +275,10 @@ impl VirtualOp {
             WQOP(r1, r2, r3, _) => vec![r1, r2, r3],
             WQML(r1, r2, r3, _) => vec![r1, r2, r3],
             WQDV(r1, r2, r3, _) => vec![r1, r2, r3],
+            WQMD(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             WQCM(r1, r2, r3, _) => vec![r1, r2, r3],
             WQAM(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
+            WQMM(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
 
             /* Control Flow Instructions */
             JMP(r1) => vec![r1],
@@ -283,7 +314,9 @@ impl VirtualOp {
             CCP(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             CROO(r1, r2) => vec![r1, r2],
             CSIZ(r1, r2) => vec![r1, r2],
-            LDC(r1, r2, r3) => vec![r1, r2, r3],
+            BSIZ(r1, r2) => vec![r1, r2],
+            LDC(r1, r2, r3, _i0) => vec![r1, r2, r3],
+            BLDD(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             LOG(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             LOGD(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             MINT(r1, r2) => vec![r1, r2],
@@ -302,7 +335,7 @@ impl VirtualOp {
             /* Cryptographic Instructions */
             ECK1(r1, r2, r3) => vec![r1, r2, r3],
             ECR1(r1, r2, r3) => vec![r1, r2, r3],
-            ED19(r1, r2, r3) => vec![r1, r2, r3],
+            ED19(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             K256(r1, r2, r3) => vec![r1, r2, r3],
             S256(r1, r2, r3) => vec![r1, r2, r3],
 
@@ -367,6 +400,7 @@ impl VirtualOp {
             |  BAL(_, _, _)
             |  BHEI(_)
             | CSIZ(_, _)
+            | BSIZ(_, _)
             | SRW(_, _, _)
             | TIME(_, _)
             |  GM(_, _)
@@ -379,8 +413,10 @@ impl VirtualOp {
             WQOP(_, _, _, _)
             | WQML(_, _, _, _)
             | WQDV(_, _, _, _)
+            | WQMD(_, _, _, _)
             | WQCM(_, _, _, _)
             | WQAM(_, _, _, _)
+            | WQMM(_, _, _, _)
             | JMP(_)
             | JI(_)
             | JNE(_, _, _)
@@ -406,7 +442,8 @@ impl VirtualOp {
             | CB(_)
             | CCP(_, _, _, _)
             | CROO(_, _)
-            | LDC(_, _, _)
+            | LDC(_, _, _, _)
+            | BLDD(_, _, _, _)
             | LOG(_, _, _, _)
             | LOGD(_, _, _, _)
             | MINT(_, _)
@@ -421,7 +458,7 @@ impl VirtualOp {
             | TRO(_, _, _, _)
             | ECK1(_, _, _)
             | ECR1(_, _, _)
-            | ED19(_, _, _)
+            | ED19(_, _, _, _)
             | K256(_, _, _)
             | S256(_, _, _)
             | FLAG(_)
@@ -472,12 +509,14 @@ impl VirtualOp {
             | WQOP(_, _, _, _)
             | WQML(_, _, _, _)
             | WQDV(_, _, _, _)
+            | WQMD(_, _, _, _)
             | WQCM(_, _, _, _)
             | WQAM(_, _, _, _)
+            | WQMM(_, _, _, _)
             // Cryptographic
             | ECK1(_, _, _)
             | ECR1(_, _, _)
-            | ED19(_, _, _)
+            | ED19(_, _, _, _)
              => vec![&VirtualRegister::Constant(Overflow), &VirtualRegister::Constant(Error)],
             FLAG(_) => vec![&VirtualRegister::Constant(Flags)],
             JMP(_)
@@ -509,7 +548,9 @@ impl VirtualOp {
             | CCP(_, _, _, _)
             | CROO(_, _)
             | CSIZ(_, _)
-            | LDC(_, _, _)
+            | BSIZ(_, _)
+            | LDC(_, _, _, _)
+            | BLDD(_, _, _, _)
             | LOG(_, _, _, _)
             | LOGD(_, _, _, _)
             | MINT(_, _)
@@ -573,11 +614,16 @@ impl VirtualOp {
             SUBI(_r1, r2, _i) => vec![r2],
             XOR(_r1, r2, r3) => vec![r2, r3],
             XORI(_r1, r2, _i) => vec![r2],
+            // Note that most of the `WQ..` instructions *read* from the `r1` result register,
+            // because the register itself does not contain the result, but provides the
+            // memory address at which the result will be stored.
             WQOP(r1, r2, r3, _) => vec![r1, r2, r3],
             WQML(r1, r2, r3, _) => vec![r1, r2, r3],
             WQDV(r1, r2, r3, _) => vec![r1, r2, r3],
+            WQMD(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             WQCM(_, r2, r3, _) => vec![r2, r3],
-            WQAM(_, r2, r3, r4) => vec![r2, r3, r4],
+            WQAM(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
+            WQMM(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
 
             /* Control Flow Instructions */
             JMP(r1) => vec![r1],
@@ -613,7 +659,9 @@ impl VirtualOp {
             CCP(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             CROO(r1, r2) => vec![r1, r2],
             CSIZ(_r1, r2) => vec![r2],
-            LDC(r1, r2, r3) => vec![r1, r2, r3],
+            BSIZ(_r1, r2) => vec![r2],
+            LDC(r1, r2, r3, _i0) => vec![r1, r2, r3],
+            BLDD(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             LOG(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             LOGD(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             MINT(r1, r2) => vec![r1, r2],
@@ -632,7 +680,7 @@ impl VirtualOp {
             /* Cryptographic Instructions */
             ECK1(r1, r2, r3) => vec![r1, r2, r3],
             ECR1(r1, r2, r3) => vec![r1, r2, r3],
-            ED19(r1, r2, r3) => vec![r1, r2, r3],
+            ED19(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             K256(r1, r2, r3) => vec![r1, r2, r3],
             S256(r1, r2, r3) => vec![r1, r2, r3],
 
@@ -693,8 +741,10 @@ impl VirtualOp {
             WQOP(_, _, _, _) => vec![],
             WQML(_, _, _, _) => vec![],
             WQDV(_, _, _, _) => vec![],
+            WQMD(_, _, _, _) => vec![],
             WQCM(r1, _, _, _) => vec![r1],
-            WQAM(r1, _, _, _) => vec![r1],
+            WQAM(_, _, _, _) => vec![],
+            WQMM(_, _, _, _) => vec![],
 
             /* Control Flow Instructions */
             JMP(_r1) => vec![],
@@ -730,7 +780,9 @@ impl VirtualOp {
             CCP(_r1, _r2, _r3, _r4) => vec![],
             CROO(_r1, _r2) => vec![],
             CSIZ(r1, _r2) => vec![r1],
-            LDC(_r1, _r2, _r3) => vec![],
+            BSIZ(r1, _r2) => vec![r1],
+            LDC(_r1, _r2, _r3, _i0) => vec![],
+            BLDD(_r1, _r2, _r3, _i0) => vec![],
             LOG(_r1, _r2, _r3, _r4) => vec![],
             LOGD(_r1, _r2, _r3, _r4) => vec![],
             MINT(_r1, _r2) => vec![],
@@ -749,7 +801,7 @@ impl VirtualOp {
             /* Cryptographic Instructions */
             ECK1(_r1, _r2, _r3) => vec![],
             ECR1(_r1, _r2, _r3) => vec![],
-            ED19(_r1, _r2, _r3) => vec![],
+            ED19(_r1, _r2, _r3, _r4) => vec![],
             K256(_r1, _r2, _r3) => vec![],
             S256(_r1, _r2, _r3) => vec![],
 
@@ -960,6 +1012,12 @@ impl VirtualOp {
                 update_reg(reg_to_reg_map, r3),
                 i.clone(),
             ),
+            WQMD(r1, r2, r3, r4) => Self::WQMD(
+                update_reg(reg_to_reg_map, r1),
+                update_reg(reg_to_reg_map, r2),
+                update_reg(reg_to_reg_map, r3),
+                update_reg(reg_to_reg_map, r4),
+            ),
             WQCM(r1, r2, r3, i) => Self::WQCM(
                 update_reg(reg_to_reg_map, r1),
                 update_reg(reg_to_reg_map, r2),
@@ -972,6 +1030,12 @@ impl VirtualOp {
                 update_reg(reg_to_reg_map, r3),
                 update_reg(reg_to_reg_map, r4),
             ),
+            WQMM(r1, r2, r3, r4) => Self::WQMM(
+                update_reg(reg_to_reg_map, r1),
+                update_reg(reg_to_reg_map, r2),
+                update_reg(reg_to_reg_map, r3),
+                update_reg(reg_to_reg_map, r4),
+            ),
 
             /* Control Flow Instructions */
             JMP(r1) => Self::JMP(update_reg(reg_to_reg_map, r1)),
@@ -1073,10 +1137,21 @@ impl VirtualOp {
                 update_reg(reg_to_reg_map, r1),
                 update_reg(reg_to_reg_map, r2),
             ),
-            LDC(r1, r2, r3) => Self::LDC(
+            BSIZ(r1, r2) => Self::BSIZ(
+                update_reg(reg_to_reg_map, r1),
+                update_reg(reg_to_reg_map, r2),
+            ),
+            LDC(r1, r2, r3, i0) => Self::LDC(
                 update_reg(reg_to_reg_map, r1),
                 update_reg(reg_to_reg_map, r2),
                 update_reg(reg_to_reg_map, r3),
+                i0.clone(),
+            ),
+            BLDD(r1, r2, r3, r4) => Self::BLDD(
+                update_reg(reg_to_reg_map, r1),
+                update_reg(reg_to_reg_map, r2),
+                update_reg(reg_to_reg_map, r3),
+                update_reg(reg_to_reg_map, r4),
             ),
             LOG(r1, r2, r3, r4) => Self::LOG(
                 update_reg(reg_to_reg_map, r1),
@@ -1159,10 +1234,11 @@ impl VirtualOp {
                 update_reg(reg_to_reg_map, r2),
                 update_reg(reg_to_reg_map, r3),
             ),
-            ED19(r1, r2, r3) => Self::ED19(
+            ED19(r1, r2, r3, r4) => Self::ED19(
                 update_reg(reg_to_reg_map, r1),
                 update_reg(reg_to_reg_map, r2),
                 update_reg(reg_to_reg_map, r3),
+                update_reg(reg_to_reg_map, r4),
             ),
             K256(r1, r2, r3) => Self::K256(
                 update_reg(reg_to_reg_map, r1),
@@ -1425,6 +1501,12 @@ impl VirtualOp {
                 map_reg(&mapping, reg3),
                 imm.clone(),
             ),
+            WQMD(reg1, reg2, reg3, reg4) => AllocatedOpcode::WQMD(
+                map_reg(&mapping, reg1),
+                map_reg(&mapping, reg2),
+                map_reg(&mapping, reg3),
+                map_reg(&mapping, reg4),
+            ),
             WQCM(reg1, reg2, reg3, imm) => AllocatedOpcode::WQCM(
                 map_reg(&mapping, reg1),
                 map_reg(&mapping, reg2),
@@ -1437,6 +1519,12 @@ impl VirtualOp {
                 map_reg(&mapping, reg3),
                 map_reg(&mapping, reg4),
             ),
+            WQMM(reg1, reg2, reg3, reg4) => AllocatedOpcode::WQMM(
+                map_reg(&mapping, reg1),
+                map_reg(&mapping, reg2),
+                map_reg(&mapping, reg3),
+                map_reg(&mapping, reg4),
+            ),
 
             /* Control Flow Instructions */
             JMP(reg1) => AllocatedOpcode::JMP(map_reg(&mapping, reg1)),
@@ -1533,10 +1621,20 @@ impl VirtualOp {
             CSIZ(reg1, reg2) => {
                 AllocatedOpcode::CSIZ(map_reg(&mapping, reg1), map_reg(&mapping, reg2))
             }
-            LDC(reg1, reg2, reg3) => AllocatedOpcode::LDC(
+            BSIZ(reg1, reg2) => {
+                AllocatedOpcode::BSIZ(map_reg(&mapping, reg1), map_reg(&mapping, reg2))
+            }
+            LDC(reg1, reg2, reg3, imm0) => AllocatedOpcode::LDC(
                 map_reg(&mapping, reg1),
                 map_reg(&mapping, reg2),
                 map_reg(&mapping, reg3),
+                imm0.clone(),
+            ),
+            BLDD(reg1, reg2, reg3, reg4) => AllocatedOpcode::BLDD(
+                map_reg(&mapping, reg1),
+                map_reg(&mapping, reg2),
+                map_reg(&mapping, reg3),
+                map_reg(&mapping, reg4),
             ),
             LOG(reg1, reg2, reg3, reg4) => AllocatedOpcode::LOG(
                 map_reg(&mapping, reg1),
@@ -1616,10 +1714,11 @@ impl VirtualOp {
                 map_reg(&mapping, reg2),
                 map_reg(&mapping, reg3),
             ),
-            ED19(reg1, reg2, reg3) => AllocatedOpcode::ED19(
+            ED19(reg1, reg2, reg3, reg4) => AllocatedOpcode::ED19(
                 map_reg(&mapping, reg1),
                 map_reg(&mapping, reg2),
                 map_reg(&mapping, reg3),
+                map_reg(&mapping, reg4),
             ),
             K256(reg1, reg2, reg3) => AllocatedOpcode::K256(
                 map_reg(&mapping, reg1),
diff --git a/sway-core/src/build_config.rs b/sway-core/src/build_config.rs
index b79f2112d66..ba96971d4a7 100644
--- a/sway-core/src/build_config.rs
+++ b/sway-core/src/build_config.rs
@@ -32,10 +32,6 @@ pub enum BuildTarget {
     #[clap(name = "evm")]
     #[strum(serialize = "evm")]
     EVM,
-    #[serde(rename = "midenvm")]
-    #[clap(name = "midenvm")]
-    #[strum(serialize = "midenvm")]
-    MidenVM,
 }
 
 #[derive(Serialize, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
@@ -187,6 +183,7 @@ pub struct BuildConfig {
     pub(crate) print_dca_graph_url_format: Option<String>,
     pub(crate) print_asm: PrintAsm,
     pub(crate) print_bytecode: bool,
+    pub(crate) print_bytecode_spans: bool,
     pub(crate) print_ir: PrintIr,
     pub(crate) include_tests: bool,
     pub(crate) optimization_level: OptLevel,
@@ -234,6 +231,7 @@ impl BuildConfig {
             print_dca_graph_url_format: None,
             print_asm: PrintAsm::default(),
             print_bytecode: false,
+            print_bytecode_spans: false,
             print_ir: PrintIr::default(),
             include_tests: false,
             time_phases: false,
@@ -264,9 +262,10 @@ impl BuildConfig {
         Self { print_asm, ..self }
     }
 
-    pub fn with_print_bytecode(self, a: bool) -> Self {
+    pub fn with_print_bytecode(self, bytecode: bool, bytecode_spans: bool) -> Self {
         Self {
-            print_bytecode: a,
+            print_bytecode: bytecode,
+            print_bytecode_spans: bytecode_spans,
             ..self
         }
     }
diff --git a/sway-core/src/compiler_generated.rs b/sway-core/src/compiler_generated.rs
index 822a3eb2dd7..2a56a655461 100644
--- a/sway-core/src/compiler_generated.rs
+++ b/sway-core/src/compiler_generated.rs
@@ -2,8 +2,6 @@
 //! e.g., unique names of variables in desugared code and similar.
 //! It also provides functions for inspecting such generated elements.
 
-use std::usize;
-
 /// The prefix for the compiler generated names of tuples.
 const TUPLE_VAR_NAME_PREFIX: &str = "__tuple_";
 
diff --git a/sway-core/src/control_flow_analysis/analyze_return_paths.rs b/sway-core/src/control_flow_analysis/analyze_return_paths.rs
index ae18d50f7e5..dc32308875f 100644
--- a/sway-core/src/control_flow_analysis/analyze_return_paths.rs
+++ b/sway-core/src/control_flow_analysis/analyze_return_paths.rs
@@ -23,11 +23,11 @@ impl<'cfg> ControlFlowGraph<'cfg> {
 
         let mut graph = ControlFlowGraph::new(engines);
         // do a depth first traversal and cover individual inner ast nodes
-        let mut leaves = vec![];
+        let mut leaf_opt = None;
         for ast_entrypoint in module_nodes {
-            match connect_node(engines, ast_entrypoint, &mut graph, &leaves) {
-                Ok(NodeConnection::NextStep(nodes)) => {
-                    leaves = nodes;
+            match connect_node(engines, ast_entrypoint, &mut graph, leaf_opt) {
+                Ok(NodeConnection::NextStep(node_opt)) => {
+                    leaf_opt = node_opt;
                 }
                 Ok(_) => {}
                 Err(mut e) => {
@@ -72,6 +72,12 @@ impl<'cfg> ControlFlowGraph<'cfg> {
         errors
     }
 
+    /// Traverses the spine of a function to ensure that it does return if a return value is
+    /// expected.  The spine of the function does not include branches such as if-then-elses and
+    /// loops. Those branches are ignored, and a branching expression is represented as a single
+    /// node in the graph. The analysis continues once the branches join again.  This means that the
+    /// spine is linear, so every node has at most one outgoing edge. The graph is assumed to have
+    /// been constructed this way.
     fn ensure_all_paths_reach_exit(
         &self,
         engines: &Engines,
@@ -80,32 +86,28 @@ impl<'cfg> ControlFlowGraph<'cfg> {
         function_name: &IdentUnique,
         return_ty: &TypeInfo,
     ) -> Vec<CompileError> {
-        let mut rovers = vec![entry_point];
+        let mut rover = entry_point;
         let mut errors = vec![];
-        let mut max_iterations = 50;
-        while !rovers.is_empty() && rovers[0] != exit_point && max_iterations > 0 {
-            max_iterations -= 1;
-            rovers.retain(|idx| *idx != exit_point);
-            let mut next_rovers = vec![];
-            let mut last_discovered_span;
-            for rover in rovers {
-                last_discovered_span = match &self.graph[rover] {
-                    ControlFlowGraphNode::ProgramNode { node, .. } => Some(node.span.clone()),
-                    ControlFlowGraphNode::MethodDeclaration { span, .. } => Some(span.clone()),
-                    _ => None,
-                };
 
-                let mut neighbors = self
-                    .graph
-                    .neighbors_directed(rover, petgraph::Direction::Outgoing)
-                    .collect::<Vec<_>>();
-                if neighbors.is_empty() && !return_ty.is_unit() {
-                    let span = match last_discovered_span {
-                        Some(ref o) => o.clone(),
-                        None => {
+        while rover != exit_point {
+            let neighbors = self
+                .graph
+                .neighbors_directed(rover, petgraph::Direction::Outgoing)
+                .collect::<Vec<_>>();
+
+            // The graph is supposed to be a single path, so at most one outgoing neighbor is allowed.
+            assert!(neighbors.len() <= 1);
+
+            if neighbors.is_empty() {
+                if !return_ty.is_unit() {
+                    // A return is expected, but none is found. Report an error.
+                    let span = match &self.graph[rover] {
+                        ControlFlowGraphNode::ProgramNode { node, .. } => node.span.clone(),
+                        ControlFlowGraphNode::MethodDeclaration { span, .. } => span.clone(),
+                        _ => {
                             errors.push(CompileError::Internal(
                                 "Attempted to construct return path error \
-                                    but no source span was found.",
+				 but no source span was found.",
                                 Span::dummy(),
                             ));
                             return errors;
@@ -113,16 +115,17 @@ impl<'cfg> ControlFlowGraph<'cfg> {
                     };
                     let function_name: Ident = function_name.into();
                     errors.push(CompileError::PathDoesNotReturn {
-                        // TODO: unwrap_to_node is a shortcut. In reality, the graph type should be
-                        // different. To save some code duplication,
                         span,
                         function_name: function_name.clone(),
                         ty: engines.help_out(return_ty).to_string(),
                     });
                 }
-                next_rovers.append(&mut neighbors);
+
+                // No further neighbors, so we're done.
+                break;
             }
-            rovers = next_rovers;
+
+            rover = neighbors[0];
         }
 
         errors
@@ -132,7 +135,7 @@ impl<'cfg> ControlFlowGraph<'cfg> {
 /// The resulting edges from connecting a node to the graph.
 enum NodeConnection {
     /// This represents a node that steps on to the next node.
-    NextStep(Vec<NodeIndex>),
+    NextStep(Option<NodeIndex>),
     /// This represents a return or implicit return node, which aborts the stepwise flow.
     Return(NodeIndex),
 }
@@ -141,7 +144,7 @@ fn connect_node<'eng: 'cfg, 'cfg>(
     engines: &'eng Engines,
     node: &ty::TyAstNode,
     graph: &mut ControlFlowGraph<'cfg>,
-    leaves: &[NodeIndex],
+    leaf_opt: Option<NodeIndex>,
 ) -> Result<NodeConnection, Vec<CompileError>> {
     match &node.content {
         ty::TyAstNodeContent::Expression(ty::TyExpression {
@@ -153,8 +156,8 @@ fn connect_node<'eng: 'cfg, 'cfg>(
             ..
         }) => {
             let this_index = graph.add_node(ControlFlowGraphNode::from_node(node));
-            for leaf_ix in leaves {
-                graph.add_edge(*leaf_ix, this_index, "".into());
+            if let Some(leaf_ix) = leaf_opt {
+                graph.add_edge(leaf_ix, this_index, "".into());
             }
             Ok(NodeConnection::Return(this_index))
         }
@@ -166,25 +169,25 @@ fn connect_node<'eng: 'cfg, 'cfg>(
             // since we don't really care about what the loop body contains when detecting
             // divergent paths
             let node = graph.add_node(ControlFlowGraphNode::from_node(node));
-            for leaf in leaves {
-                graph.add_edge(*leaf, node, "while loop entry".into());
+            if let Some(leaf) = leaf_opt {
+                graph.add_edge(leaf, node, "while loop entry".into());
             }
-            Ok(NodeConnection::NextStep(vec![node]))
+            Ok(NodeConnection::NextStep(Some(node)))
         }
         ty::TyAstNodeContent::Expression(ty::TyExpression { .. }) => {
             let entry = graph.add_node(ControlFlowGraphNode::from_node(node));
             // insert organizational dominator node
             // connected to all current leaves
-            for leaf in leaves {
-                graph.add_edge(*leaf, entry, "".into());
+            if let Some(leaf) = leaf_opt {
+                graph.add_edge(leaf, entry, "".into());
             }
-            Ok(NodeConnection::NextStep(vec![entry]))
+            Ok(NodeConnection::NextStep(Some(entry)))
         }
-        ty::TyAstNodeContent::SideEffect(_) => Ok(NodeConnection::NextStep(leaves.to_vec())),
+        ty::TyAstNodeContent::SideEffect(_) => Ok(NodeConnection::NextStep(leaf_opt)),
         ty::TyAstNodeContent::Declaration(decl) => Ok(NodeConnection::NextStep(
-            connect_declaration(engines, node, decl, graph, leaves)?,
+            connect_declaration(engines, node, decl, graph, leaf_opt)?,
         )),
-        ty::TyAstNodeContent::Error(_, _) => Ok(NodeConnection::NextStep(vec![])),
+        ty::TyAstNodeContent::Error(_, _) => Ok(NodeConnection::NextStep(None)),
     }
 }
 
@@ -193,8 +196,8 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
     node: &ty::TyAstNode,
     decl: &ty::TyDecl,
     graph: &mut ControlFlowGraph<'cfg>,
-    leaves: &[NodeIndex],
-) -> Result<Vec<NodeIndex>, Vec<CompileError>> {
+    leaf_opt: Option<NodeIndex>,
+) -> Result<Option<NodeIndex>, Vec<CompileError>> {
     let decl_engine = engines.de();
     match decl {
         ty::TyDecl::TraitDecl(_)
@@ -205,39 +208,33 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
         | ty::TyDecl::StorageDecl(_)
         | ty::TyDecl::TypeAliasDecl(_)
         | ty::TyDecl::TraitTypeDecl(_)
-        | ty::TyDecl::GenericTypeForFunctionScope(_) => Ok(leaves.to_vec()),
+        | ty::TyDecl::GenericTypeForFunctionScope(_) => Ok(leaf_opt),
         ty::TyDecl::VariableDecl(_)
         | ty::TyDecl::ConstantDecl(_)
         | ty::TyDecl::ConfigurableDecl(_) => {
             let entry_node = graph.add_node(ControlFlowGraphNode::from_node(node));
-            for leaf in leaves {
-                graph.add_edge(*leaf, entry_node, "".into());
+            if let Some(leaf) = leaf_opt {
+                graph.add_edge(leaf, entry_node, "".into());
             }
-            Ok(vec![entry_node])
+            Ok(Some(entry_node))
         }
         ty::TyDecl::FunctionDecl(ty::FunctionDecl { decl_id, .. }) => {
             let fn_decl = decl_engine.get_function(decl_id);
             let entry_node = graph.add_node(ControlFlowGraphNode::from_node(node));
-            for leaf in leaves {
-                graph.add_edge(*leaf, entry_node, "".into());
-            }
+            // Do not connect the leaves to the function entry point, since control cannot flow from them into the function.
             connect_typed_fn_decl(engines, &fn_decl, graph, entry_node)?;
-            Ok(leaves.to_vec())
+            Ok(leaf_opt)
         }
-        ty::TyDecl::ImplTrait(ty::ImplTrait { decl_id, .. }) => {
-            let impl_trait = decl_engine.get_impl_trait(decl_id);
-            let ty::TyImplTrait {
+        ty::TyDecl::ImplSelfOrTrait(ty::ImplSelfOrTrait { decl_id, .. }) => {
+            let impl_trait = decl_engine.get_impl_self_or_trait(decl_id);
+            let ty::TyImplSelfOrTrait {
                 trait_name, items, ..
             } = &*impl_trait;
-            let entry_node = graph.add_node(ControlFlowGraphNode::from_node(node));
-            for leaf in leaves {
-                graph.add_edge(*leaf, entry_node, "".into());
-            }
-
-            connect_impl_trait(engines, trait_name, graph, items, entry_node)?;
-            Ok(leaves.to_vec())
+            // Do not connect the leaves to the impl entry point, since control cannot flow from them into the impl.
+            connect_impl_trait(engines, trait_name, graph, items)?;
+            Ok(leaf_opt)
         }
-        ty::TyDecl::ErrorRecovery(..) => Ok(leaves.to_vec()),
+        ty::TyDecl::ErrorRecovery(..) => Ok(leaf_opt),
     }
 }
 
@@ -251,7 +248,6 @@ fn connect_impl_trait<'eng: 'cfg, 'cfg>(
     trait_name: &CallPath,
     graph: &mut ControlFlowGraph<'cfg>,
     items: &[TyImplItem],
-    entry_node: NodeIndex,
 ) -> Result<(), Vec<CompileError>> {
     let decl_engine = engines.de();
     let mut methods_and_indexes = vec![];
@@ -266,7 +262,6 @@ fn connect_impl_trait<'eng: 'cfg, 'cfg>(
                     method_decl_ref: method_decl_ref.clone(),
                     engines,
                 });
-                graph.add_edge(entry_node, fn_decl_entry_node, "".into());
                 // connect the impl declaration node to the functions themselves, as all trait functions are
                 // public if the trait is in scope
                 connect_typed_fn_decl(engines, &fn_decl, graph, fn_decl_entry_node)?;
@@ -305,7 +300,7 @@ fn connect_typed_fn_decl<'eng: 'cfg, 'cfg>(
     let type_engine = engines.te();
     let fn_exit_node = graph.add_node(format!("\"{}\" fn exit", fn_decl.name.as_str()).into());
     let return_nodes =
-        depth_first_insertion_code_block(engines, &fn_decl.body, graph, &[entry_node])?;
+        depth_first_insertion_code_block(engines, &fn_decl.body, graph, Some(entry_node))?;
     for node in return_nodes {
         graph.add_edge(node, fn_exit_node, "return".into());
     }
@@ -327,16 +322,15 @@ fn depth_first_insertion_code_block<'eng: 'cfg, 'cfg>(
     engines: &'eng Engines,
     node_content: &ty::TyCodeBlock,
     graph: &mut ControlFlowGraph<'cfg>,
-    leaves: &[NodeIndex],
+    init_leaf_opt: Option<NodeIndex>,
 ) -> Result<ReturnStatementNodes, Vec<CompileError>> {
     let mut errors = vec![];
-
-    let mut leaves = leaves.to_vec();
+    let mut leaf_opt = init_leaf_opt;
     let mut return_nodes = vec![];
     for node in node_content.contents.iter() {
-        match connect_node(engines, node, graph, &leaves) {
+        match connect_node(engines, node, graph, leaf_opt) {
             Ok(this_node) => match this_node {
-                NodeConnection::NextStep(nodes) => leaves = nodes,
+                NodeConnection::NextStep(node_opt) => leaf_opt = node_opt,
                 NodeConnection::Return(node) => {
                     return_nodes.push(node);
                 }
diff --git a/sway-core/src/control_flow_analysis/dead_code_analysis.rs b/sway-core/src/control_flow_analysis/dead_code_analysis.rs
index e15c6f84ef0..60843dbf3dd 100644
--- a/sway-core/src/control_flow_analysis/dead_code_analysis.rs
+++ b/sway-core/src/control_flow_analysis/dead_code_analysis.rs
@@ -4,8 +4,8 @@ use crate::{
     language::{
         parsed::TreeType,
         ty::{
-            self, ConstantDecl, FunctionDecl, ProjectionKind, StructDecl, TraitDecl, TyAstNode,
-            TyAstNodeContent, TyDecl, TyImplItem, TypeAliasDecl,
+            self, ConfigurableDecl, ConstantDecl, FunctionDecl, ProjectionKind, StructDecl,
+            TraitDecl, TyAstNode, TyAstNodeContent, TyDecl, TyImplItem, TypeAliasDecl,
         },
         CallPath, Visibility,
     },
@@ -70,7 +70,7 @@ fn is_entry_point(node: &TyAstNode, decl_engine: &DeclEngine, tree_type: &TreeTy
                 struct_decl.visibility == Visibility::Public
             }
             TyAstNode {
-                content: TyAstNodeContent::Declaration(TyDecl::ImplTrait { .. }),
+                content: TyAstNodeContent::Declaration(TyDecl::ImplSelfOrTrait { .. }),
                 ..
             } => true,
             TyAstNode {
@@ -81,6 +81,11 @@ fn is_entry_point(node: &TyAstNode, decl_engine: &DeclEngine, tree_type: &TreeTy
                 let decl = decl_engine.get_constant(decl_id);
                 decl.visibility.is_public()
             }
+            TyAstNode {
+                content:
+                    TyAstNodeContent::Declaration(TyDecl::ConfigurableDecl(ConfigurableDecl { .. })),
+                ..
+            } => false,
             TyAstNode {
                 content:
                     TyAstNodeContent::Declaration(TyDecl::TypeAliasDecl(TypeAliasDecl {
@@ -193,7 +198,10 @@ impl<'cfg> ControlFlowGraph<'cfg> {
                 ControlFlowGraphNode::ProgramNode {
                     node:
                         ty::TyAstNode {
-                            content: ty::TyAstNodeContent::Declaration(ty::TyDecl::ImplTrait { .. }),
+                            content:
+                                ty::TyAstNodeContent::Declaration(ty::TyDecl::ImplSelfOrTrait {
+                                    ..
+                                }),
                             ..
                         },
                     ..
@@ -567,11 +575,18 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
         ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl { decl_id, .. }) => {
             let config_decl = decl_engine.get_configurable(decl_id);
             let ty::TyConfigurableDecl {
-                call_path, value, ..
+                call_path,
+                value,
+                type_ascription,
+                ..
             } = &*config_decl;
+
             graph
                 .namespace
                 .insert_configurable(call_path.suffix.clone(), entry_node);
+
+            connect_type_id(engines, type_ascription.type_id, graph, entry_node)?;
+
             if let Some(value) = &value {
                 connect_expression(
                     engines,
@@ -579,7 +594,7 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
                     graph,
                     &[entry_node],
                     exit_node,
-                    "constant declaration expression",
+                    "configurable declaration expression",
                     tree_type,
                     value.span.clone(),
                     options,
@@ -620,9 +635,9 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
             connect_enum_declaration(&enum_decl, *enum_ref.id(), graph, entry_node);
             Ok(leaves.to_vec())
         }
-        ty::TyDecl::ImplTrait(ty::ImplTrait { decl_id, .. }) => {
-            let impl_trait_decl = decl_engine.get_impl_trait(decl_id);
-            let ty::TyImplTrait {
+        ty::TyDecl::ImplSelfOrTrait(ty::ImplSelfOrTrait { decl_id, .. }) => {
+            let impl_trait_decl = decl_engine.get_impl_self_or_trait(decl_id);
+            let ty::TyImplSelfOrTrait {
                 trait_name,
                 items,
                 trait_decl_ref,
@@ -683,7 +698,6 @@ fn connect_struct_declaration<'eng: 'cfg, 'cfg>(
                 graph.add_node(ControlFlowGraphNode::StructField {
                     struct_decl_id,
                     struct_field_name: field.name.clone(),
-                    span: field.span.clone(),
                     attributes: field.attributes.clone(),
                 }),
             )
@@ -956,6 +970,9 @@ fn get_struct_type_info_from_type_id(
         TypeInfo::Array(type_arg, _) => {
             get_struct_type_info_from_type_id(type_engine, decl_engine, type_arg.type_id)
         }
+        TypeInfo::Slice(type_arg) => {
+            get_struct_type_info_from_type_id(type_engine, decl_engine, type_arg.type_id)
+        }
         _ => Ok(None),
     }
 }
@@ -1157,8 +1174,8 @@ fn get_trait_fn_node_index<'a>(
                     .namespace
                     .find_trait_method(&struct_decl.call_path.suffix.clone().into(), &fn_decl.name))
             }
-            ty::TyDecl::ImplTrait(ty::ImplTrait { decl_id, .. }) => {
-                let impl_trait = decl_engine.get_impl_trait(decl_id);
+            ty::TyDecl::ImplSelfOrTrait(ty::ImplSelfOrTrait { decl_id, .. }) => {
+                let impl_trait = decl_engine.get_impl_self_or_trait(decl_id);
                 Ok(graph
                     .namespace
                     .find_trait_method(&impl_trait.trait_name, &fn_decl.name))
@@ -1580,11 +1597,15 @@ fn connect_expression<'eng: 'cfg, 'cfg>(
             connect_code_block(engines, a, graph, leaves, exit_node, tree_type, options)
         }
         StructExpression {
-            struct_ref, fields, ..
+            struct_id, fields, ..
         } => {
-            let decl = match graph.namespace.find_struct_decl(struct_ref.name().as_str()) {
+            let struct_decl = engines.de().get_struct(struct_id);
+            let decl = match graph
+                .namespace
+                .find_struct_decl(struct_decl.name().as_str())
+            {
                 Some(ix) => *ix,
-                None => graph.add_node(format!("External struct  {}", struct_ref.name()).into()),
+                None => graph.add_node(format!("External struct  {}", struct_decl.name()).into()),
             };
             let entry = graph.add_node("Struct declaration entry".into());
             let exit = graph.add_node("Struct declaration exit".into());
@@ -1597,7 +1618,7 @@ fn connect_expression<'eng: 'cfg, 'cfg>(
 
             // connect the struct fields to the struct if its requested as an option
             if options.force_struct_fields_connection {
-                if let Some(ns) = graph.namespace.get_struct(struct_ref.name()).cloned() {
+                if let Some(ns) = graph.namespace.get_struct(struct_decl.name()).cloned() {
                     for (_, field_ix) in ns.fields.iter() {
                         graph.add_edge(decl, *field_ix, "".into());
                     }
@@ -1774,35 +1795,28 @@ fn connect_expression<'eng: 'cfg, 'cfg>(
             elem_type: _,
             contents,
         } => {
-            let mut element_diverge = false;
-            let nodes = contents
-                .iter()
-                .map(|elem| {
-                    if !element_diverge
-                        && type_engine
-                            .get(elem.return_type)
-                            .is_uninhabited(engines.te(), engines.de())
-                    {
-                        element_diverge = true
-                    }
-                    connect_expression(
-                        engines,
-                        &elem.expression,
-                        graph,
-                        leaves,
-                        exit_node,
-                        "",
-                        tree_type,
-                        elem.span.clone(),
-                        options,
-                    )
-                })
-                .collect::<Result<Vec<_>, _>>()?;
-            if element_diverge {
-                Ok(vec![])
-            } else {
-                Ok(nodes.concat())
+            let mut last = leaves.to_vec();
+
+            for elem in contents.iter() {
+                last = connect_expression(
+                    engines,
+                    &elem.expression,
+                    graph,
+                    last.as_slice(),
+                    None,
+                    "",
+                    tree_type,
+                    elem.span.clone(),
+                    options,
+                )?;
+
+                // If an element diverges, break the connections and return nothing
+                if last.is_empty() {
+                    break;
+                }
             }
+
+            Ok(last)
         }
         ArrayIndex { prefix, index } => {
             let prefix_idx = connect_expression(
@@ -2305,6 +2319,16 @@ fn construct_dead_code_warning_from_node(
             span: decl_engine.get_constant(decl_id).name().span(),
             warning_content: Warning::DeadDeclaration,
         },
+        ty::TyAstNode {
+            content:
+                ty::TyAstNodeContent::Declaration(ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl {
+                    decl_id,
+                })),
+            ..
+        } => CompileWarning {
+            span: decl_engine.get_configurable(decl_id).name().span(),
+            warning_content: Warning::DeadDeclaration,
+        },
         ty::TyAstNode {
             content: ty::TyAstNodeContent::Declaration(ty::TyDecl::VariableDecl(decl)),
             span,
@@ -2326,12 +2350,13 @@ fn construct_dead_code_warning_from_node(
         }
         ty::TyAstNode {
             content:
-                ty::TyAstNodeContent::Declaration(ty::TyDecl::ImplTrait(ty::ImplTrait {
-                    decl_id, ..
+                ty::TyAstNodeContent::Declaration(ty::TyDecl::ImplSelfOrTrait(ty::ImplSelfOrTrait {
+                    decl_id,
+                    ..
                 })),
             span,
         } => {
-            let ty::TyImplTrait { .. } = &*decl_engine.get_impl_trait(decl_id);
+            let ty::TyImplSelfOrTrait { .. } = &*decl_engine.get_impl_self_or_trait(decl_id);
             CompileWarning {
                 span: span.clone(),
                 warning_content: Warning::DeadDeclaration,
@@ -2529,7 +2554,7 @@ fn allow_dead_code_ast_node(decl_engine: &DeclEngine, node: &ty::TyAstNode) -> b
             ty::TyDecl::TypeAliasDecl(ty::TypeAliasDecl { decl_id, .. }) => {
                 allow_dead_code(decl_engine.get_type_alias(decl_id).attributes.clone())
             }
-            ty::TyDecl::ImplTrait { .. } => false,
+            ty::TyDecl::ImplSelfOrTrait { .. } => false,
             ty::TyDecl::AbiDecl { .. } => false,
             ty::TyDecl::GenericTypeForFunctionScope { .. } => false,
             ty::TyDecl::ErrorRecovery(..) => false,
diff --git a/sway-core/src/control_flow_analysis/flow_graph/mod.rs b/sway-core/src/control_flow_analysis/flow_graph/mod.rs
index 8c7aa6ad157..ebc9f15f267 100644
--- a/sway-core/src/control_flow_analysis/flow_graph/mod.rs
+++ b/sway-core/src/control_flow_analysis/flow_graph/mod.rs
@@ -90,7 +90,6 @@ pub enum ControlFlowGraphNode<'cfg> {
         struct_decl_id: DeclId<ty::TyStructDecl>,
         struct_field_name: Ident,
         attributes: transform::AttributesMap,
-        span: Span,
     },
     StorageField {
         field_name: Ident,
diff --git a/sway-core/src/decl_engine/engine.rs b/sway-core/src/decl_engine/engine.rs
index 6b96d9932ac..65033e65f9e 100644
--- a/sway-core/src/decl_engine/engine.rs
+++ b/sway-core/src/decl_engine/engine.rs
@@ -5,16 +5,24 @@ use std::{
     sync::Arc,
 };
 
-use sway_types::{Named, ProgramId, Spanned};
+use sway_types::{Named, ProgramId, SourceId, Spanned};
 
 use crate::{
     concurrent_slab::ConcurrentSlab,
-    decl_engine::*,
+    decl_engine::{parsed_id::ParsedDeclId, *},
     engine_threading::*,
-    language::ty::{
-        self, TyAbiDecl, TyConfigurableDecl, TyConstantDecl, TyEnumDecl, TyFunctionDecl,
-        TyImplTrait, TyStorageDecl, TyStructDecl, TyTraitDecl, TyTraitFn, TyTraitType,
-        TyTypeAliasDecl,
+    language::{
+        parsed::{
+            AbiDeclaration, ConfigurableDeclaration, ConstantDeclaration, Declaration,
+            EnumDeclaration, FunctionDeclaration, ImplSelfOrTrait, StorageDeclaration,
+            StructDeclaration, TraitDeclaration, TraitFn, TraitTypeDeclaration,
+            TypeAliasDeclaration,
+        },
+        ty::{
+            self, TyAbiDecl, TyConfigurableDecl, TyConstantDecl, TyDeclParsedType, TyEnumDecl,
+            TyFunctionDecl, TyImplSelfOrTrait, TyStorageDecl, TyStructDecl, TyTraitDecl, TyTraitFn,
+            TyTraitType, TyTypeAliasDecl,
+        },
     },
 };
 
@@ -25,7 +33,7 @@ pub struct DeclEngine {
     trait_slab: ConcurrentSlab<TyTraitDecl>,
     trait_fn_slab: ConcurrentSlab<TyTraitFn>,
     trait_type_slab: ConcurrentSlab<TyTraitType>,
-    impl_trait_slab: ConcurrentSlab<TyImplTrait>,
+    impl_self_or_trait_slab: ConcurrentSlab<TyImplSelfOrTrait>,
     struct_slab: ConcurrentSlab<TyStructDecl>,
     storage_slab: ConcurrentSlab<TyStorageDecl>,
     abi_slab: ConcurrentSlab<TyAbiDecl>,
@@ -34,6 +42,27 @@ pub struct DeclEngine {
     enum_slab: ConcurrentSlab<TyEnumDecl>,
     type_alias_slab: ConcurrentSlab<TyTypeAliasDecl>,
 
+    function_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyFunctionDecl>, ParsedDeclId<FunctionDeclaration>>>,
+    trait_parsed_decl_id_map: RwLock<HashMap<DeclId<TyTraitDecl>, ParsedDeclId<TraitDeclaration>>>,
+    trait_fn_parsed_decl_id_map: RwLock<HashMap<DeclId<TyTraitFn>, ParsedDeclId<TraitFn>>>,
+    trait_type_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyTraitType>, ParsedDeclId<TraitTypeDeclaration>>>,
+    impl_self_or_trait_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyImplSelfOrTrait>, ParsedDeclId<ImplSelfOrTrait>>>,
+    struct_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyStructDecl>, ParsedDeclId<StructDeclaration>>>,
+    storage_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyStorageDecl>, ParsedDeclId<StorageDeclaration>>>,
+    abi_parsed_decl_id_map: RwLock<HashMap<DeclId<TyAbiDecl>, ParsedDeclId<AbiDeclaration>>>,
+    constant_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyConstantDecl>, ParsedDeclId<ConstantDeclaration>>>,
+    configurable_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyConfigurableDecl>, ParsedDeclId<ConfigurableDeclaration>>>,
+    enum_parsed_decl_id_map: RwLock<HashMap<DeclId<TyEnumDecl>, ParsedDeclId<EnumDeclaration>>>,
+    type_alias_parsed_decl_id_map:
+        RwLock<HashMap<DeclId<TyTypeAliasDecl>, ParsedDeclId<TypeAliasDeclaration>>>,
+
     parents: RwLock<HashMap<AssociatedItemDeclId, Vec<AssociatedItemDeclId>>>,
 }
 
@@ -44,7 +73,7 @@ impl Clone for DeclEngine {
             trait_slab: self.trait_slab.clone(),
             trait_fn_slab: self.trait_fn_slab.clone(),
             trait_type_slab: self.trait_type_slab.clone(),
-            impl_trait_slab: self.impl_trait_slab.clone(),
+            impl_self_or_trait_slab: self.impl_self_or_trait_slab.clone(),
             struct_slab: self.struct_slab.clone(),
             storage_slab: self.storage_slab.clone(),
             abi_slab: self.abi_slab.clone(),
@@ -52,6 +81,32 @@ impl Clone for DeclEngine {
             configurable_slab: self.configurable_slab.clone(),
             enum_slab: self.enum_slab.clone(),
             type_alias_slab: self.type_alias_slab.clone(),
+            function_parsed_decl_id_map: RwLock::new(
+                self.function_parsed_decl_id_map.read().clone(),
+            ),
+            trait_parsed_decl_id_map: RwLock::new(self.trait_parsed_decl_id_map.read().clone()),
+            trait_fn_parsed_decl_id_map: RwLock::new(
+                self.trait_fn_parsed_decl_id_map.read().clone(),
+            ),
+            trait_type_parsed_decl_id_map: RwLock::new(
+                self.trait_type_parsed_decl_id_map.read().clone(),
+            ),
+            impl_self_or_trait_parsed_decl_id_map: RwLock::new(
+                self.impl_self_or_trait_parsed_decl_id_map.read().clone(),
+            ),
+            struct_parsed_decl_id_map: RwLock::new(self.struct_parsed_decl_id_map.read().clone()),
+            storage_parsed_decl_id_map: RwLock::new(self.storage_parsed_decl_id_map.read().clone()),
+            abi_parsed_decl_id_map: RwLock::new(self.abi_parsed_decl_id_map.read().clone()),
+            constant_parsed_decl_id_map: RwLock::new(
+                self.constant_parsed_decl_id_map.read().clone(),
+            ),
+            configurable_parsed_decl_id_map: RwLock::new(
+                self.configurable_parsed_decl_id_map.read().clone(),
+            ),
+            enum_parsed_decl_id_map: RwLock::new(self.enum_parsed_decl_id_map.read().clone()),
+            type_alias_parsed_decl_id_map: RwLock::new(
+                self.type_alias_parsed_decl_id_map.read().clone(),
+            ),
             parents: RwLock::new(self.parents.read().clone()),
         }
     }
@@ -61,26 +116,47 @@ pub trait DeclEngineGet<I, U> {
     fn get(&self, index: &I) -> Arc<U>;
 }
 
+pub trait DeclEngineGetParsedDeclId<T>
+where
+    T: TyDeclParsedType,
+{
+    fn get_parsed_decl_id(&self, decl_id: &DeclId<T>) -> Option<ParsedDeclId<T::ParsedType>>;
+}
+
+pub trait DeclEngineGetParsedDecl<T>
+where
+    T: TyDeclParsedType,
+{
+    fn get_parsed_decl(&self, decl_id: &DeclId<T>) -> Option<Declaration>;
+}
+
 pub trait DeclEngineInsert<T>
 where
-    T: Named + Spanned,
+    T: Named + Spanned + TyDeclParsedType,
 {
-    fn insert(&self, decl: T) -> DeclRef<DeclId<T>>;
+    fn insert(
+        &self,
+        decl: T,
+        parsed_decl_id: Option<&ParsedDeclId<T::ParsedType>>,
+    ) -> DeclRef<DeclId<T>>;
 }
 
 pub trait DeclEngineInsertArc<T>
 where
-    T: Named + Spanned,
+    T: Named + Spanned + TyDeclParsedType,
 {
-    fn insert_arc(&self, decl: Arc<T>) -> DeclRef<DeclId<T>>;
+    fn insert_arc(
+        &self,
+        decl: Arc<T>,
+        parsed_decl_id: Option<&ParsedDeclId<T::ParsedType>>,
+    ) -> DeclRef<DeclId<T>>;
 }
 
 pub trait DeclEngineReplace<T> {
     fn replace(&self, index: DeclId<T>, decl: T);
 }
 
-pub trait DeclEngineIndex<T>:
-    DeclEngineGet<DeclId<T>, T> + DeclEngineInsert<T> + DeclEngineReplace<T>
+pub trait DeclEngineIndex<T>: DeclEngineGet<DeclId<T>, T> + DeclEngineReplace<T>
 where
     T: Named + Spanned,
 {
@@ -105,7 +181,7 @@ decl_engine_get!(function_slab, ty::TyFunctionDecl);
 decl_engine_get!(trait_slab, ty::TyTraitDecl);
 decl_engine_get!(trait_fn_slab, ty::TyTraitFn);
 decl_engine_get!(trait_type_slab, ty::TyTraitType);
-decl_engine_get!(impl_trait_slab, ty::TyImplTrait);
+decl_engine_get!(impl_self_or_trait_slab, ty::TyImplSelfOrTrait);
 decl_engine_get!(struct_slab, ty::TyStructDecl);
 decl_engine_get!(storage_slab, ty::TyStorageDecl);
 decl_engine_get!(abi_slab, ty::TyAbiDecl);
@@ -115,41 +191,186 @@ decl_engine_get!(enum_slab, ty::TyEnumDecl);
 decl_engine_get!(type_alias_slab, ty::TyTypeAliasDecl);
 
 macro_rules! decl_engine_insert {
-    ($slab:ident, $decl:ty) => {
+    ($slab:ident, $parsed_slab:ident, $decl:ty) => {
         impl DeclEngineInsert<$decl> for DeclEngine {
-            fn insert(&self, decl: $decl) -> DeclRef<DeclId<$decl>> {
+            fn insert(
+                &self,
+                decl: $decl,
+                parsed_decl_id: Option<&ParsedDeclId<<$decl as TyDeclParsedType>::ParsedType>>,
+            ) -> DeclRef<DeclId<$decl>> {
                 let span = decl.span();
-                DeclRef::new(
-                    decl.name().clone(),
-                    DeclId::new(self.$slab.insert(decl)),
-                    span,
-                )
+                let decl_name = decl.name().clone();
+                let decl_id = DeclId::new(self.$slab.insert(decl));
+                if let Some(parsed_decl_id) = parsed_decl_id {
+                    self.$parsed_slab
+                        .write()
+                        .insert(decl_id, parsed_decl_id.clone());
+                }
+                DeclRef::new(decl_name, decl_id, span)
             }
         }
         impl DeclEngineInsertArc<$decl> for DeclEngine {
-            fn insert_arc(&self, decl: Arc<$decl>) -> DeclRef<DeclId<$decl>> {
+            fn insert_arc(
+                &self,
+                decl: Arc<$decl>,
+                parsed_decl_id: Option<&ParsedDeclId<<$decl as TyDeclParsedType>::ParsedType>>,
+            ) -> DeclRef<DeclId<$decl>> {
                 let span = decl.span();
-                DeclRef::new(
-                    decl.name().clone(),
-                    DeclId::new(self.$slab.insert_arc(decl)),
-                    span,
-                )
+                let decl_name = decl.name().clone();
+                let decl_id = DeclId::new(self.$slab.insert_arc(decl));
+                if let Some(parsed_decl_id) = parsed_decl_id {
+                    self.$parsed_slab
+                        .write()
+                        .insert(decl_id, parsed_decl_id.clone());
+                }
+                DeclRef::new(decl_name, decl_id, span)
             }
         }
     };
 }
-decl_engine_insert!(function_slab, ty::TyFunctionDecl);
-decl_engine_insert!(trait_slab, ty::TyTraitDecl);
-decl_engine_insert!(trait_fn_slab, ty::TyTraitFn);
-decl_engine_insert!(trait_type_slab, ty::TyTraitType);
-decl_engine_insert!(impl_trait_slab, ty::TyImplTrait);
-decl_engine_insert!(struct_slab, ty::TyStructDecl);
-decl_engine_insert!(storage_slab, ty::TyStorageDecl);
-decl_engine_insert!(abi_slab, ty::TyAbiDecl);
-decl_engine_insert!(constant_slab, ty::TyConstantDecl);
-decl_engine_insert!(configurable_slab, ty::TyConfigurableDecl);
-decl_engine_insert!(enum_slab, ty::TyEnumDecl);
-decl_engine_insert!(type_alias_slab, ty::TyTypeAliasDecl);
+decl_engine_insert!(
+    function_slab,
+    function_parsed_decl_id_map,
+    ty::TyFunctionDecl
+);
+decl_engine_insert!(trait_slab, trait_parsed_decl_id_map, ty::TyTraitDecl);
+decl_engine_insert!(trait_fn_slab, trait_fn_parsed_decl_id_map, ty::TyTraitFn);
+decl_engine_insert!(
+    trait_type_slab,
+    trait_type_parsed_decl_id_map,
+    ty::TyTraitType
+);
+decl_engine_insert!(
+    impl_self_or_trait_slab,
+    impl_self_or_trait_parsed_decl_id_map,
+    ty::TyImplSelfOrTrait
+);
+decl_engine_insert!(struct_slab, struct_parsed_decl_id_map, ty::TyStructDecl);
+decl_engine_insert!(storage_slab, storage_parsed_decl_id_map, ty::TyStorageDecl);
+decl_engine_insert!(abi_slab, abi_parsed_decl_id_map, ty::TyAbiDecl);
+decl_engine_insert!(
+    constant_slab,
+    constant_parsed_decl_id_map,
+    ty::TyConstantDecl
+);
+decl_engine_insert!(
+    configurable_slab,
+    configurable_parsed_decl_id_map,
+    ty::TyConfigurableDecl
+);
+decl_engine_insert!(enum_slab, enum_parsed_decl_id_map, ty::TyEnumDecl);
+decl_engine_insert!(
+    type_alias_slab,
+    type_alias_parsed_decl_id_map,
+    ty::TyTypeAliasDecl
+);
+
+macro_rules! decl_engine_parsed_decl_id {
+    ($slab:ident, $decl:ty) => {
+        impl DeclEngineGetParsedDeclId<$decl> for DeclEngine {
+            fn get_parsed_decl_id(
+                &self,
+                decl_id: &DeclId<$decl>,
+            ) -> Option<ParsedDeclId<<$decl as TyDeclParsedType>::ParsedType>> {
+                let parsed_decl_id_map = self.$slab.read();
+                if let Some(parsed_decl_id) = parsed_decl_id_map.get(&decl_id) {
+                    return Some(parsed_decl_id.clone());
+                } else {
+                    None
+                }
+            }
+        }
+    };
+}
+
+decl_engine_parsed_decl_id!(function_parsed_decl_id_map, ty::TyFunctionDecl);
+decl_engine_parsed_decl_id!(trait_parsed_decl_id_map, ty::TyTraitDecl);
+decl_engine_parsed_decl_id!(trait_fn_parsed_decl_id_map, ty::TyTraitFn);
+decl_engine_parsed_decl_id!(trait_type_parsed_decl_id_map, ty::TyTraitType);
+decl_engine_parsed_decl_id!(impl_self_or_trait_parsed_decl_id_map, ty::TyImplSelfOrTrait);
+decl_engine_parsed_decl_id!(struct_parsed_decl_id_map, ty::TyStructDecl);
+decl_engine_parsed_decl_id!(storage_parsed_decl_id_map, ty::TyStorageDecl);
+decl_engine_parsed_decl_id!(abi_parsed_decl_id_map, ty::TyAbiDecl);
+decl_engine_parsed_decl_id!(constant_parsed_decl_id_map, ty::TyConstantDecl);
+decl_engine_parsed_decl_id!(configurable_parsed_decl_id_map, ty::TyConfigurableDecl);
+decl_engine_parsed_decl_id!(enum_parsed_decl_id_map, ty::TyEnumDecl);
+decl_engine_parsed_decl_id!(type_alias_parsed_decl_id_map, ty::TyTypeAliasDecl);
+
+macro_rules! decl_engine_parsed_decl {
+    ($slab:ident, $decl:ty, $ctor:expr) => {
+        impl DeclEngineGetParsedDecl<$decl> for DeclEngine {
+            fn get_parsed_decl(&self, decl_id: &DeclId<$decl>) -> Option<Declaration> {
+                let parsed_decl_id_map = self.$slab.read();
+                if let Some(parsed_decl_id) = parsed_decl_id_map.get(&decl_id) {
+                    return Some($ctor(parsed_decl_id.clone()));
+                } else {
+                    None
+                }
+            }
+        }
+    };
+}
+
+decl_engine_parsed_decl!(
+    function_parsed_decl_id_map,
+    ty::TyFunctionDecl,
+    Declaration::FunctionDeclaration
+);
+decl_engine_parsed_decl!(
+    trait_parsed_decl_id_map,
+    ty::TyTraitDecl,
+    Declaration::TraitDeclaration
+);
+decl_engine_parsed_decl!(
+    trait_fn_parsed_decl_id_map,
+    ty::TyTraitFn,
+    Declaration::TraitFnDeclaration
+);
+decl_engine_parsed_decl!(
+    trait_type_parsed_decl_id_map,
+    ty::TyTraitType,
+    Declaration::TraitTypeDeclaration
+);
+decl_engine_parsed_decl!(
+    impl_self_or_trait_parsed_decl_id_map,
+    ty::TyImplSelfOrTrait,
+    Declaration::ImplSelfOrTrait
+);
+decl_engine_parsed_decl!(
+    struct_parsed_decl_id_map,
+    ty::TyStructDecl,
+    Declaration::StructDeclaration
+);
+decl_engine_parsed_decl!(
+    storage_parsed_decl_id_map,
+    ty::TyStorageDecl,
+    Declaration::StorageDeclaration
+);
+decl_engine_parsed_decl!(
+    abi_parsed_decl_id_map,
+    ty::TyAbiDecl,
+    Declaration::AbiDeclaration
+);
+decl_engine_parsed_decl!(
+    constant_parsed_decl_id_map,
+    ty::TyConstantDecl,
+    Declaration::ConstantDeclaration
+);
+decl_engine_parsed_decl!(
+    configurable_parsed_decl_id_map,
+    ty::TyConfigurableDecl,
+    Declaration::ConfigurableDeclaration
+);
+decl_engine_parsed_decl!(
+    enum_parsed_decl_id_map,
+    ty::TyEnumDecl,
+    Declaration::EnumDeclaration
+);
+decl_engine_parsed_decl!(
+    type_alias_parsed_decl_id_map,
+    ty::TyTypeAliasDecl,
+    Declaration::TypeAliasDeclaration
+);
 
 macro_rules! decl_engine_replace {
     ($slab:ident, $decl:ty) => {
@@ -164,7 +385,7 @@ decl_engine_replace!(function_slab, ty::TyFunctionDecl);
 decl_engine_replace!(trait_slab, ty::TyTraitDecl);
 decl_engine_replace!(trait_fn_slab, ty::TyTraitFn);
 decl_engine_replace!(trait_type_slab, ty::TyTraitType);
-decl_engine_replace!(impl_trait_slab, ty::TyImplTrait);
+decl_engine_replace!(impl_self_or_trait_slab, ty::TyImplSelfOrTrait);
 decl_engine_replace!(struct_slab, ty::TyStructDecl);
 decl_engine_replace!(storage_slab, ty::TyStorageDecl);
 decl_engine_replace!(abi_slab, ty::TyAbiDecl);
@@ -182,7 +403,7 @@ decl_engine_index!(function_slab, ty::TyFunctionDecl);
 decl_engine_index!(trait_slab, ty::TyTraitDecl);
 decl_engine_index!(trait_fn_slab, ty::TyTraitFn);
 decl_engine_index!(trait_type_slab, ty::TyTraitType);
-decl_engine_index!(impl_trait_slab, ty::TyImplTrait);
+decl_engine_index!(impl_self_or_trait_slab, ty::TyImplSelfOrTrait);
 decl_engine_index!(struct_slab, ty::TyStructDecl);
 decl_engine_index!(storage_slab, ty::TyStorageDecl);
 decl_engine_index!(abi_slab, ty::TyAbiDecl);
@@ -228,7 +449,54 @@ decl_engine_clear_program!(
     trait_slab, ty::TyTraitDecl;
     trait_fn_slab, ty::TyTraitFn;
     trait_type_slab, ty::TyTraitType;
-    impl_trait_slab, ty::TyImplTrait;
+    impl_self_or_trait_slab, ty::TyImplTrait;
+    struct_slab, ty::TyStructDecl;
+    storage_slab, ty::TyStorageDecl;
+    abi_slab, ty::TyAbiDecl;
+    constant_slab, ty::TyConstantDecl;
+    configurable_slab, ty::TyConfigurableDecl;
+    enum_slab, ty::TyEnumDecl;
+    type_alias_slab, ty::TyTypeAliasDecl;
+);
+
+macro_rules! decl_engine_clear_module {
+    ($($slab:ident, $decl:ty);* $(;)?) => {
+        impl DeclEngine {
+            pub fn clear_module(&mut self, source_id: &SourceId) {
+                self.parents.write().retain(|key, _| {
+                    match key {
+                        AssociatedItemDeclId::TraitFn(decl_id) => {
+                            self.get_trait_fn(decl_id).span().source_id().map_or(true, |src_id| src_id != source_id)
+                        },
+                        AssociatedItemDeclId::Function(decl_id) => {
+                            self.get_function(decl_id).span().source_id().map_or(true, |src_id| src_id != source_id)
+                        },
+                        AssociatedItemDeclId::Type(decl_id) => {
+                            self.get_type(decl_id).span().source_id().map_or(true, |src_id| src_id != source_id)
+                        },
+                        AssociatedItemDeclId::Constant(decl_id) => {
+                            self.get_constant(decl_id).span().source_id().map_or(true, |src_id| src_id != source_id)
+                        },
+                    }
+                });
+
+                $(
+                    self.$slab.retain(|_k, ty| match ty.span().source_id() {
+                        Some(src_id) => src_id != source_id,
+                        None => true,
+                    });
+                )*
+            }
+        }
+    };
+}
+
+decl_engine_clear_module!(
+    function_slab, ty::TyFunctionDecl;
+    trait_slab, ty::TyTraitDecl;
+    trait_fn_slab, ty::TyTraitFn;
+    trait_type_slab, ty::TyTraitType;
+    impl_self_or_trait_slab, ty::TyImplTrait;
     struct_slab, ty::TyStructDecl;
     storage_slab, ty::TyStorageDecl;
     abi_slab, ty::TyAbiDecl;
@@ -360,9 +628,9 @@ impl DeclEngine {
     ///
     /// Calling [DeclEngine][get] directly is equivalent to this method, but
     /// this method adds additional syntax that some users may find helpful.
-    pub fn get_impl_trait<I>(&self, index: &I) -> Arc<ty::TyImplTrait>
+    pub fn get_impl_self_or_trait<I>(&self, index: &I) -> Arc<ty::TyImplSelfOrTrait>
     where
-        DeclEngine: DeclEngineGet<I, ty::TyImplTrait>,
+        DeclEngine: DeclEngineGet<I, ty::TyImplSelfOrTrait>,
     {
         self.get(index)
     }
diff --git a/sway-core/src/decl_engine/id.rs b/sway-core/src/decl_engine/id.rs
index 2a177956ab5..8878b9aaa79 100644
--- a/sway-core/src/decl_engine/id.rs
+++ b/sway-core/src/decl_engine/id.rs
@@ -3,12 +3,14 @@ use std::hash::Hasher;
 use std::marker::PhantomData;
 use std::{fmt, hash::Hash};
 
-use crate::language::ty::TyTraitType;
+use sway_types::{Named, Spanned};
+
+use crate::language::ty::{TyDeclParsedType, TyTraitType};
 use crate::{
     decl_engine::*,
     engine_threading::*,
     language::ty::{
-        TyEnumDecl, TyFunctionDecl, TyImplTrait, TyStructDecl, TyTraitDecl, TyTraitFn,
+        TyEnumDecl, TyFunctionDecl, TyImplSelfOrTrait, TyStructDecl, TyTraitDecl, TyTraitFn,
         TyTypeAliasDecl,
     },
     type_system::*,
@@ -96,11 +98,55 @@ impl<T> Into<usize> for DeclId<T> {
     }
 }
 
-impl SubstTypes for DeclId<TyFunctionDecl> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+impl<T> DebugWithEngines for DeclId<T>
+where
+    DeclEngine: DeclEngineIndex<T>,
+    T: Named + Spanned + DebugWithEngines,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
+        let decl = engines.de().get(self);
+        DebugWithEngines::fmt(&decl, f, engines)
+    }
+}
+
+impl<T> EqWithEngines for DeclId<T>
+where
+    DeclEngine: DeclEngineIndex<T>,
+    T: Named + Spanned + PartialEqWithEngines + EqWithEngines,
+{
+}
+
+impl<T> PartialEqWithEngines for DeclId<T>
+where
+    DeclEngine: DeclEngineIndex<T>,
+    T: Named + Spanned + PartialEqWithEngines,
+{
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        let decl_engine = ctx.engines().de();
+        let l_decl = decl_engine.get(self);
+        let r_decl = decl_engine.get(other);
+        l_decl.name() == r_decl.name() && l_decl.eq(&r_decl, ctx)
+    }
+}
+
+impl<T> HashWithEngines for DeclId<T>
+where
+    DeclEngine: DeclEngineIndex<T>,
+    T: Named + Spanned + HashWithEngines,
+{
+    fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
         let decl_engine = engines.de();
+        let decl = decl_engine.get(self);
+        decl.name().hash(state);
+        decl.hash(state, engines);
+    }
+}
+
+impl SubstTypes for DeclId<TyFunctionDecl> {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -109,10 +155,10 @@ impl SubstTypes for DeclId<TyFunctionDecl> {
     }
 }
 impl SubstTypes for DeclId<TyTraitDecl> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -121,10 +167,10 @@ impl SubstTypes for DeclId<TyTraitDecl> {
     }
 }
 impl SubstTypes for DeclId<TyTraitFn> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -132,11 +178,11 @@ impl SubstTypes for DeclId<TyTraitFn> {
         }
     }
 }
-impl SubstTypes for DeclId<TyImplTrait> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+impl SubstTypes for DeclId<TyImplSelfOrTrait> {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -145,10 +191,10 @@ impl SubstTypes for DeclId<TyImplTrait> {
     }
 }
 impl SubstTypes for DeclId<TyStructDecl> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -157,10 +203,10 @@ impl SubstTypes for DeclId<TyStructDecl> {
     }
 }
 impl SubstTypes for DeclId<TyEnumDecl> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -169,10 +215,10 @@ impl SubstTypes for DeclId<TyEnumDecl> {
     }
 }
 impl SubstTypes for DeclId<TyTypeAliasDecl> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -182,10 +228,10 @@ impl SubstTypes for DeclId<TyTypeAliasDecl> {
 }
 
 impl SubstTypes for DeclId<TyTraitType> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(self)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(*self, decl);
             HasChanges::Yes
         } else {
@@ -193,3 +239,22 @@ impl SubstTypes for DeclId<TyTraitType> {
         }
     }
 }
+
+impl<T> DeclId<T>
+where
+    DeclEngine: DeclEngineIndex<T> + DeclEngineInsert<T> + DeclEngineGetParsedDeclId<T>,
+    T: Named + Spanned + SubstTypes + Clone + TyDeclParsedType,
+{
+    pub(crate) fn subst_types_and_insert_new(
+        &self,
+        ctx: &SubstTypesContext,
+    ) -> Option<DeclRef<Self>> {
+        let decl_engine = ctx.engines.de();
+        let mut decl = (*decl_engine.get(self)).clone();
+        if decl.subst(ctx).has_changes() {
+            Some(decl_engine.insert(decl, decl_engine.get_parsed_decl_id(self).as_ref()))
+        } else {
+            None
+        }
+    }
+}
diff --git a/sway-core/src/decl_engine/mod.rs b/sway-core/src/decl_engine/mod.rs
index 94f6e7987f7..78f4c3ab256 100644
--- a/sway-core/src/decl_engine/mod.rs
+++ b/sway-core/src/decl_engine/mod.rs
@@ -26,6 +26,7 @@ pub use engine::*;
 pub(crate) use id::*;
 pub use interface_decl_id::*;
 pub(crate) use mapping::*;
+pub use parsed_engine::*;
 pub use r#ref::*;
 pub(crate) use replace_decls::*;
 use sway_types::Ident;
diff --git a/sway-core/src/decl_engine/parsed_engine.rs b/sway-core/src/decl_engine/parsed_engine.rs
index 059e12c4c6f..5c330346fd9 100644
--- a/sway-core/src/decl_engine/parsed_engine.rs
+++ b/sway-core/src/decl_engine/parsed_engine.rs
@@ -1,15 +1,14 @@
 use crate::{
     concurrent_slab::ConcurrentSlab,
-    decl_engine::*,
     language::parsed::{
         AbiDeclaration, ConfigurableDeclaration, ConstantDeclaration, EnumDeclaration, EnumVariant,
-        FunctionDeclaration, ImplSelf, ImplTrait, StorageDeclaration, StructDeclaration,
+        FunctionDeclaration, ImplSelfOrTrait, StorageDeclaration, StructDeclaration,
         TraitDeclaration, TraitFn, TraitTypeDeclaration, TypeAliasDeclaration, VariableDeclaration,
     },
 };
 
 use std::sync::Arc;
-use sway_types::{ProgramId, Spanned};
+use sway_types::{ProgramId, SourceId, Spanned};
 
 use super::parsed_id::ParsedDeclId;
 
@@ -21,8 +20,7 @@ pub struct ParsedDeclEngine {
     trait_slab: ConcurrentSlab<TraitDeclaration>,
     trait_fn_slab: ConcurrentSlab<TraitFn>,
     trait_type_slab: ConcurrentSlab<TraitTypeDeclaration>,
-    impl_trait_slab: ConcurrentSlab<ImplTrait>,
-    impl_self_slab: ConcurrentSlab<ImplSelf>,
+    impl_self_or_trait_slab: ConcurrentSlab<ImplSelfOrTrait>,
     struct_slab: ConcurrentSlab<StructDeclaration>,
     storage_slab: ConcurrentSlab<StorageDeclaration>,
     abi_slab: ConcurrentSlab<AbiDeclaration>,
@@ -41,16 +39,14 @@ pub trait ParsedDeclEngineInsert<T> {
     fn insert(&self, decl: T) -> ParsedDeclId<T>;
 }
 
-pub trait ParsedDeclEngineInsertArc<T> {
-    fn insert_arc(&self, decl: Arc<T>) -> ParsedDeclId<T>;
-}
-
+#[allow(unused)]
 pub trait ParsedDeclEngineReplace<T> {
     fn replace(&self, index: ParsedDeclId<T>, decl: T);
 }
 
+#[allow(unused)]
 pub trait ParsedDeclEngineIndex<T>:
-    ParsedDeclEngineGet<DeclId<T>, T> + ParsedDeclEngineInsert<T> + ParsedDeclEngineReplace<T>
+    ParsedDeclEngineGet<ParsedDeclId<T>, T> + ParsedDeclEngineInsert<T> + ParsedDeclEngineReplace<T>
 {
 }
 
@@ -68,8 +64,7 @@ decl_engine_get!(function_slab, FunctionDeclaration);
 decl_engine_get!(trait_slab, TraitDeclaration);
 decl_engine_get!(trait_fn_slab, TraitFn);
 decl_engine_get!(trait_type_slab, TraitTypeDeclaration);
-decl_engine_get!(impl_trait_slab, ImplTrait);
-decl_engine_get!(impl_self_slab, ImplSelf);
+decl_engine_get!(impl_self_or_trait_slab, ImplSelfOrTrait);
 decl_engine_get!(struct_slab, StructDeclaration);
 decl_engine_get!(storage_slab, StorageDeclaration);
 decl_engine_get!(abi_slab, AbiDeclaration);
@@ -86,11 +81,6 @@ macro_rules! decl_engine_insert {
                 ParsedDeclId::new(self.$slab.insert(decl))
             }
         }
-        impl ParsedDeclEngineInsertArc<$decl> for ParsedDeclEngine {
-            fn insert_arc(&self, decl: Arc<$decl>) -> ParsedDeclId<$decl> {
-                ParsedDeclId::new(self.$slab.insert_arc(decl))
-            }
-        }
     };
 }
 
@@ -99,8 +89,7 @@ decl_engine_insert!(function_slab, FunctionDeclaration);
 decl_engine_insert!(trait_slab, TraitDeclaration);
 decl_engine_insert!(trait_fn_slab, TraitFn);
 decl_engine_insert!(trait_type_slab, TraitTypeDeclaration);
-decl_engine_insert!(impl_trait_slab, ImplTrait);
-decl_engine_insert!(impl_self_slab, ImplSelf);
+decl_engine_insert!(impl_self_or_trait_slab, ImplSelfOrTrait);
 decl_engine_insert!(struct_slab, StructDeclaration);
 decl_engine_insert!(storage_slab, StorageDeclaration);
 decl_engine_insert!(abi_slab, AbiDeclaration);
@@ -110,6 +99,30 @@ decl_engine_insert!(enum_slab, EnumDeclaration);
 decl_engine_insert!(enum_variant_slab, EnumVariant);
 decl_engine_insert!(type_alias_slab, TypeAliasDeclaration);
 
+macro_rules! decl_engine_replace {
+    ($slab:ident, $decl:ty) => {
+        impl ParsedDeclEngineReplace<$decl> for ParsedDeclEngine {
+            fn replace(&self, index: ParsedDeclId<$decl>, decl: $decl) {
+                self.$slab.replace(index.inner(), decl);
+            }
+        }
+    };
+}
+
+decl_engine_replace!(variable_slab, VariableDeclaration);
+decl_engine_replace!(function_slab, FunctionDeclaration);
+decl_engine_replace!(trait_slab, TraitDeclaration);
+decl_engine_replace!(trait_fn_slab, TraitFn);
+decl_engine_replace!(trait_type_slab, TraitTypeDeclaration);
+decl_engine_replace!(impl_self_or_trait_slab, ImplSelfOrTrait);
+decl_engine_replace!(struct_slab, StructDeclaration);
+decl_engine_replace!(storage_slab, StorageDeclaration);
+decl_engine_replace!(abi_slab, AbiDeclaration);
+decl_engine_replace!(configurable_slab, ConfigurableDeclaration);
+decl_engine_replace!(constant_slab, ConstantDeclaration);
+decl_engine_replace!(enum_slab, EnumDeclaration);
+decl_engine_replace!(type_alias_slab, TypeAliasDeclaration);
+
 macro_rules! decl_engine_clear {
     ($($slab:ident, $decl:ty);* $(;)?) => {
         impl ParsedDeclEngine {
@@ -122,14 +135,32 @@ macro_rules! decl_engine_clear {
     };
 }
 
+macro_rules! decl_engine_index {
+    ($slab:ident, $decl:ty) => {
+        impl ParsedDeclEngineIndex<$decl> for ParsedDeclEngine {}
+    };
+}
+decl_engine_index!(variable_slab, VariableDeclaration);
+decl_engine_index!(function_slab, FunctionDeclaration);
+decl_engine_index!(trait_slab, TraitDeclaration);
+decl_engine_index!(trait_fn_slab, TraitFn);
+decl_engine_index!(trait_type_slab, TraitTypeDeclaration);
+decl_engine_index!(impl_self_or_trait_slab, ImplSelfOrTrait);
+decl_engine_index!(struct_slab, StructDeclaration);
+decl_engine_index!(storage_slab, StorageDeclaration);
+decl_engine_index!(abi_slab, AbiDeclaration);
+decl_engine_index!(configurable_slab, ConfigurableDeclaration);
+decl_engine_index!(constant_slab, ConstantDeclaration);
+decl_engine_index!(enum_slab, EnumDeclaration);
+decl_engine_index!(type_alias_slab, TypeAliasDeclaration);
+
 decl_engine_clear!(
     variable_slab, VariableDeclaration;
     function_slab, FunctionDeclaration;
     trait_slab, TraitDeclaration;
     trait_fn_slab, TraitFn;
     trait_type_slab, TraitTypeDeclaration;
-    impl_trait_slab, ImplTrait;
-    impl_self_slab, ImplSelf;
+    impl_self_or_trait_slab, ImplTrait;
     struct_slab, StructDeclaration;
     storage_slab, StorageDeclaration;
     abi_slab, AbiDeclaration;
@@ -165,8 +196,49 @@ decl_engine_clear_program!(
     (trait_type_slab, |item: &TraitTypeDeclaration| item
         .name
         .span()),
-    (impl_trait_slab, |item: &ImplTrait| item.block_span.clone()),
-    (impl_self_slab, |item: &ImplSelf| item.block_span.clone()),
+    (impl_self_or_trait_slab, |item: &ImplSelfOrTrait| item
+        .block_span
+        .clone()),
+    (struct_slab, |item: &StructDeclaration| item.name.span()),
+    (storage_slab, |item: &StorageDeclaration| item.span.clone()),
+    (abi_slab, |item: &AbiDeclaration| item.name.span()),
+    (constant_slab, |item: &ConstantDeclaration| item.name.span()),
+    (enum_slab, |item: &EnumDeclaration| item.name.span()),
+    (type_alias_slab, |item: &TypeAliasDeclaration| item
+        .name
+        .span()),
+);
+
+macro_rules! decl_engine_clear_module {
+    ($(($slab:ident, $getter:expr)),* $(,)?) => {
+        impl ParsedDeclEngine {
+            pub fn clear_module(&mut self, program_id: &SourceId) {
+                $(
+                    self.$slab.retain(|_k, item| {
+                        #[allow(clippy::redundant_closure_call)]
+                        let span = $getter(item);
+                        match span.source_id() {
+                            Some(src_id) => src_id != program_id,
+                            None => true,
+                        }
+                    });
+                )*
+            }
+        }
+    };
+}
+
+decl_engine_clear_module!(
+    (variable_slab, |item: &VariableDeclaration| item.name.span()),
+    (function_slab, |item: &FunctionDeclaration| item.name.span()),
+    (trait_slab, |item: &TraitDeclaration| item.name.span()),
+    (trait_fn_slab, |item: &TraitFn| item.name.span()),
+    (trait_type_slab, |item: &TraitTypeDeclaration| item
+        .name
+        .span()),
+    (impl_self_or_trait_slab, |item: &ImplSelfOrTrait| item
+        .block_span
+        .clone()),
     (struct_slab, |item: &StructDeclaration| item.name.span()),
     (storage_slab, |item: &StorageDeclaration| item.span.clone()),
     (abi_slab, |item: &AbiDeclaration| item.name.span()),
@@ -219,21 +291,9 @@ impl ParsedDeclEngine {
     ///
     /// Calling [ParsedDeclEngine][get] directly is equivalent to this method, but
     /// this method adds additional syntax that some users may find helpful.
-    pub fn get_impl_trait<I>(&self, index: &I) -> Arc<ImplTrait>
-    where
-        ParsedDeclEngine: ParsedDeclEngineGet<I, ImplTrait>,
-    {
-        self.get(index)
-    }
-
-    /// Friendly helper method for calling the `get` method from the
-    /// implementation of [ParsedDeclEngineGet] for [ParsedDeclEngine]
-    ///
-    /// Calling [ParsedDeclEngine][get] directly is equivalent to this method, but
-    /// this method adds additional syntax that some users may find helpful.
-    pub fn get_impl_self<I>(&self, index: &I) -> Arc<ImplSelf>
+    pub fn get_impl_self_or_trait<I>(&self, index: &I) -> Arc<ImplSelfOrTrait>
     where
-        ParsedDeclEngine: ParsedDeclEngineGet<I, ImplSelf>,
+        ParsedDeclEngine: ParsedDeclEngineGet<I, ImplSelfOrTrait>,
     {
         self.get(index)
     }
diff --git a/sway-core/src/decl_engine/parsed_id.rs b/sway-core/src/decl_engine/parsed_id.rs
index 561c811c1dd..3a97459aa75 100644
--- a/sway-core/src/decl_engine/parsed_id.rs
+++ b/sway-core/src/decl_engine/parsed_id.rs
@@ -2,8 +2,14 @@ use std::hash::{DefaultHasher, Hasher};
 use std::marker::PhantomData;
 use std::{fmt, hash::Hash};
 
-use crate::engine_threading::{EqWithEngines, PartialEqWithEngines, PartialEqWithEnginesContext};
+use sway_types::{Named, Spanned};
 
+use crate::engine_threading::{
+    EqWithEngines, HashWithEngines, PartialEqWithEngines, PartialEqWithEnginesContext,
+};
+use crate::Engines;
+
+use super::parsed_engine::{ParsedDeclEngine, ParsedDeclEngineGet, ParsedDeclEngineIndex};
 use super::DeclUniqueId;
 
 pub type ParsedDeclIdIndexType = usize;
@@ -61,6 +67,19 @@ impl<T> Hash for ParsedDeclId<T> {
     }
 }
 
+impl<T> HashWithEngines for ParsedDeclId<T>
+where
+    ParsedDeclEngine: ParsedDeclEngineIndex<T>,
+    T: Named + Spanned + HashWithEngines,
+{
+    fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
+        let decl_engine = engines.pe();
+        let decl = decl_engine.get(self);
+        decl.name().hash(state);
+        decl.hash(state, engines);
+    }
+}
+
 impl<T> PartialOrd for ParsedDeclId<T> {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
diff --git a/sway-core/src/decl_engine/ref.rs b/sway-core/src/decl_engine/ref.rs
index 9d5186d33f1..663fd563a60 100644
--- a/sway-core/src/decl_engine/ref.rs
+++ b/sway-core/src/decl_engine/ref.rs
@@ -29,8 +29,8 @@ use crate::{
     decl_engine::*,
     engine_threading::*,
     language::ty::{
-        self, TyAbiDecl, TyConstantDecl, TyEnumDecl, TyFunctionDecl, TyImplTrait, TyStorageDecl,
-        TyStructDecl, TyTraitDecl, TyTraitFn, TyTraitType,
+        self, TyAbiDecl, TyConstantDecl, TyDeclParsedType, TyEnumDecl, TyFunctionDecl,
+        TyImplSelfOrTrait, TyStorageDecl, TyStructDecl, TyTraitDecl, TyTraitFn, TyTraitType,
     },
     semantic_analysis::TypeCheckContext,
     type_system::*,
@@ -40,7 +40,7 @@ pub type DeclRefFunction = DeclRef<DeclId<TyFunctionDecl>>;
 pub type DeclRefTrait = DeclRef<DeclId<TyTraitDecl>>;
 pub type DeclRefTraitFn = DeclRef<DeclId<TyTraitFn>>;
 pub type DeclRefTraitType = DeclRef<DeclId<TyTraitType>>;
-pub type DeclRefImplTrait = DeclRef<DeclId<TyImplTrait>>;
+pub type DeclRefImplTrait = DeclRef<DeclId<TyImplSelfOrTrait>>;
 pub type DeclRefStruct = DeclRef<DeclId<TyStructDecl>>;
 pub type DeclRefStorage = DeclRef<DeclId<TyStorageDecl>>;
 pub type DeclRefAbi = DeclRef<DeclId<TyAbiDecl>>;
@@ -96,18 +96,22 @@ impl<T> DeclRef<DeclId<T>> {
 
 impl<T> DeclRef<DeclId<T>>
 where
-    DeclEngine: DeclEngineIndex<T>,
-    T: Named + Spanned + SubstTypes + Clone,
+    DeclEngine: DeclEngineIndex<T> + DeclEngineInsert<T> + DeclEngineGetParsedDeclId<T>,
+    T: Named + Spanned + IsConcrete + SubstTypes + Clone + TyDeclParsedType,
 {
-    pub(crate) fn subst_types_and_insert_new(
-        &self,
-        type_mapping: &TypeSubstMap,
-        engines: &Engines,
-    ) -> Option<Self> {
-        let decl_engine = engines.de();
-        let mut decl = (*decl_engine.get(&self.id)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
-            Some(decl_engine.insert(decl))
+    pub(crate) fn subst_types_and_insert_new(&self, ctx: &SubstTypesContext) -> Option<Self> {
+        let decl_engine = ctx.engines.de();
+        if ctx
+            .type_subst_map
+            .source_ids_contains_concrete_type(ctx.engines)
+            || !decl_engine.get(&self.id).is_concrete(ctx.engines)
+        {
+            let mut decl = (*decl_engine.get(&self.id)).clone();
+            if decl.subst(ctx).has_changes() {
+                Some(decl_engine.insert(decl, decl_engine.get_parsed_decl_id(&self.id).as_ref()))
+            } else {
+                None
+            }
         } else {
             None
         }
@@ -132,20 +136,19 @@ where
 impl<T> DeclRef<DeclId<T>>
 where
     AssociatedItemDeclId: From<DeclId<T>>,
-    DeclEngine: DeclEngineIndex<T>,
-    T: Named + Spanned + SubstTypes + Clone,
+    DeclEngine: DeclEngineIndex<T> + DeclEngineInsert<T> + DeclEngineGetParsedDeclId<T>,
+    T: Named + Spanned + IsConcrete + SubstTypes + Clone + TyDeclParsedType,
 {
     pub(crate) fn subst_types_and_insert_new_with_parent(
         &self,
-        type_mapping: &TypeSubstMap,
-        engines: &Engines,
+        ctx: &SubstTypesContext,
     ) -> Option<Self> {
-        let decl_engine = engines.de();
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(&self.id)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             Some(
                 decl_engine
-                    .insert(decl)
+                    .insert(decl, decl_engine.get_parsed_decl_id(&self.id).as_ref())
                     .with_parent(decl_engine, self.id.into()),
             )
         } else {
@@ -160,6 +163,7 @@ where
     T: Named + Spanned + PartialEqWithEngines + EqWithEngines,
 {
 }
+
 impl<T> PartialEqWithEngines for DeclRef<DeclId<T>>
 where
     DeclEngine: DeclEngineIndex<T>,
@@ -256,10 +260,10 @@ where
     DeclEngine: DeclEngineIndex<T>,
     T: Named + Spanned + SubstTypes + Clone,
 {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let decl_engine = engines.de();
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let decl_engine = ctx.engines.de();
         let mut decl = (*decl_engine.get(&self.id)).clone();
-        if decl.subst(type_mapping, engines).has_changes() {
+        if decl.subst(ctx).has_changes() {
             decl_engine.replace(self.id, decl);
             HasChanges::Yes
         } else {
diff --git a/sway-core/src/engine_threading.rs b/sway-core/src/engine_threading.rs
index c698d9700f4..2af209c807f 100644
--- a/sway-core/src/engine_threading.rs
+++ b/sway-core/src/engine_threading.rs
@@ -46,6 +46,16 @@ impl Engines {
         self.type_engine.clear_program(program_id);
         self.decl_engine.clear_program(program_id);
         self.parsed_decl_engine.clear_program(program_id);
+        self.query_engine.clear_program(program_id);
+    }
+
+    /// Removes all data associated with `source_id` from the declaration and type engines.
+    /// It is intended to be used during garbage collection to remove any data that is no longer needed.
+    pub fn clear_module(&mut self, source_id: &sway_types::SourceId) {
+        self.type_engine.clear_module(source_id);
+        self.decl_engine.clear_module(source_id);
+        self.parsed_decl_engine.clear_module(source_id);
+        self.query_engine.clear_module(source_id);
     }
 
     /// Helps out some `thing: T` by adding `self` as context.
@@ -209,6 +219,12 @@ impl<T: DebugWithEngines> DebugWithEngines for Vec<T> {
     }
 }
 
+impl DebugWithEngines for Span {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
+        DisplayWithEngines::fmt(self, f, engines)
+    }
+}
+
 pub trait HashWithEngines {
     fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines);
 }
diff --git a/sway-core/src/ir_generation.rs b/sway-core/src/ir_generation.rs
index 045b1bab7e5..dc08281c82e 100644
--- a/sway-core/src/ir_generation.rs
+++ b/sway-core/src/ir_generation.rs
@@ -7,24 +7,26 @@ mod purity;
 pub mod storage;
 mod types;
 
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    hash::{DefaultHasher, Hasher},
+};
 
 use sway_error::error::CompileError;
 use sway_ir::{Context, Function, Kind, Module};
-use sway_types::{span::Span, Ident, Spanned};
+use sway_types::{span::Span, Ident};
 
 pub(crate) use purity::{check_function_purity, PurityEnv};
 
 use crate::{
+    engine_threading::HashWithEngines,
     language::ty,
     metadata::MetadataManager,
     types::{LogId, MessageId},
     Engines, ExperimentalFlags, TypeId,
 };
 
-type FnParams = Vec<TypeId>;
-type FnTypeParams = Vec<TypeId>;
-type FnKey = (Span, FnParams, FnTypeParams);
+type FnKey = u64;
 
 /// Every compiled function needs to go through this cache for two reasons:
 /// 1 - to have its IR name unique;
@@ -63,30 +65,11 @@ impl CompiledFunctionCache {
         // args and type parameters.  It's using the Sway types rather than IR types, which would
         // be more accurate but also more fiddly.
 
-        let no_span = decl.span().as_str().is_empty();
-        let is_autogenerated = context
-            .source_engine
-            .is_span_in_autogenerated(&decl.span)
-            .unwrap_or_default();
-
-        let (fn_key, item) = if no_span || is_autogenerated {
-            (None, None)
-        } else {
-            let fn_key = (
-                decl.span(),
-                decl.parameters
-                    .iter()
-                    .map(|p| p.type_argument.type_id)
-                    .collect(),
-                decl.type_parameters.iter().map(|tp| tp.type_id).collect(),
-            );
-
-            (
-                Some(fn_key.clone()),
-                self.recreated_fns.get(&fn_key).copied(),
-            )
-        };
+        let mut hasher = DefaultHasher::default();
+        decl.hash(&mut hasher, engines);
+        let fn_key = hasher.finish();
 
+        let (fn_key, item) = (Some(fn_key), self.recreated_fns.get(&fn_key).copied());
         let new_callee = match item {
             Some(func) => func,
             None => {
@@ -100,16 +83,21 @@ impl CompiledFunctionCache {
                     parameters: decl.parameters.clone(),
                     ..decl.clone()
                 };
+                // Entry functions are already compiled at the top level
+                // when compiling scripts, predicates, contracts, and libraries.
                 let is_entry = false;
+                let is_original_entry = callee_fn_decl.is_main() || callee_fn_decl.is_test();
                 let new_func = compile::compile_function(
                     engines,
                     context,
                     md_mgr,
                     module,
                     &callee_fn_decl,
+                    &decl.name,
                     logged_types_map,
                     messages_types_map,
                     is_entry,
+                    is_original_entry,
                     None,
                     self,
                 )
diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index cfd0a45d537..e7c07932fa2 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -11,16 +11,16 @@ use crate::{
 
 use super::{
     const_eval::{compile_const_decl, LookupEnv},
-    convert::convert_resolved_typeid,
+    convert::convert_resolved_type_id,
     function::FnCompiler,
     CompiledFunctionCache,
 };
 
 use sway_error::{error::CompileError, handler::Handler};
 use sway_ir::{metadata::combine as md_combine, *};
-use sway_types::Spanned;
+use sway_types::{Ident, Spanned};
 
-use std::{collections::HashMap, sync::Arc};
+use std::{cell::Cell, collections::HashMap, sync::Arc};
 
 #[allow(clippy::too_many_arguments)]
 pub(super) fn compile_script(
@@ -298,11 +298,11 @@ pub(crate) fn compile_configurables(
         {
             let decl = engines.de().get(decl_id);
 
-            let ty = convert_resolved_typeid(
+            let ty = convert_resolved_type_id(
                 engines.te(),
                 engines.de(),
                 context,
-                &decl.type_ascription.type_id,
+                decl.type_ascription.type_id,
                 &decl.type_ascription.span,
             )
             .unwrap();
@@ -322,11 +322,23 @@ pub(crate) fn compile_configurables(
             let opt_metadata = md_mgr.span_to_md(context, &decl.span);
 
             if context.experimental.new_encoding {
-                let encoded_bytes = match constant.value {
+                let mut encoded_bytes = match constant.value {
                     ConstantValue::RawUntypedSlice(bytes) => bytes,
                     _ => unreachable!(),
                 };
 
+                let config_type_info = engines.te().get(decl.type_ascription.type_id);
+                let buffer_size = match config_type_info.abi_encode_size_hint(engines) {
+                    crate::AbiEncodeSizeHint::Exact(len) => len,
+                    crate::AbiEncodeSizeHint::Range(_, len) => len,
+                    _ => unreachable!("unexpected type accepted as configurable"),
+                };
+
+                if buffer_size > encoded_bytes.len() {
+                    encoded_bytes.extend([0].repeat(buffer_size - encoded_bytes.len()));
+                }
+                assert!(encoded_bytes.len() == buffer_size);
+
                 let decode_fn = engines.de().get(decl.decode_fn.as_ref().unwrap().id());
                 let decode_fn = cache.ty_function_decl_to_unique_function(
                     engines,
@@ -347,7 +359,7 @@ pub(crate) fn compile_configurables(
                         ty,
                         ptr_ty,
                         encoded_bytes,
-                        decode_fn,
+                        decode_fn: Cell::new(decode_fn),
                         opt_metadata,
                     },
                 );
@@ -378,9 +390,11 @@ pub(super) fn compile_function(
     md_mgr: &mut MetadataManager,
     module: Module,
     ast_fn_decl: &ty::TyFunctionDecl,
+    original_name: &Ident,
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     is_entry: bool,
+    is_original_entry: bool,
     test_decl_ref: Option<DeclRefFunction>,
     cache: &mut CompiledFunctionCache,
 ) -> Result<Option<Function>, Vec<CompileError>> {
@@ -395,7 +409,9 @@ pub(super) fn compile_function(
             md_mgr,
             module,
             ast_fn_decl,
+            original_name,
             is_entry,
+            is_original_entry,
             None,
             logged_types_map,
             messages_types_map,
@@ -419,6 +435,9 @@ pub(super) fn compile_entry_function(
     cache: &mut CompiledFunctionCache,
 ) -> Result<Function, Vec<CompileError>> {
     let is_entry = true;
+    // In the new encoding, the only entry function is the `__entry`,
+    // which is not an original entry.
+    let is_original_entry = !context.experimental.new_encoding;
     let ast_fn_decl = engines.de().get_function(ast_fn_decl);
     compile_function(
         engines,
@@ -426,9 +445,11 @@ pub(super) fn compile_entry_function(
         md_mgr,
         module,
         &ast_fn_decl,
+        &ast_fn_decl.name,
         logged_types_map,
         messages_types_map,
         is_entry,
+        is_original_entry,
         test_decl_ref,
         cache,
     )
@@ -471,7 +492,13 @@ fn compile_fn(
     md_mgr: &mut MetadataManager,
     module: Module,
     ast_fn_decl: &ty::TyFunctionDecl,
+    // Original function name, before it is postfixed with
+    // a number, to get a unique name.
+    // The span in the name must point to the name in the
+    // function declaration.
+    original_name: &Ident,
     is_entry: bool,
+    is_original_entry: bool,
     selector: Option<[u8; 4]>,
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
@@ -513,11 +540,11 @@ fn compile_fn(
         .iter()
         .map(|param| {
             // Convert to an IR type.
-            convert_resolved_typeid(
+            convert_resolved_type_id(
                 type_engine,
                 decl_engine,
                 context,
-                &param.type_argument.type_id,
+                param.type_argument.type_id,
                 &param.type_argument.span,
             )
             .map(|ty| {
@@ -537,18 +564,20 @@ fn compile_fn(
         .collect::<Result<Vec<_>, CompileError>>()
         .map_err(|err| vec![err])?;
 
-    let ret_type = convert_resolved_typeid(
+    let ret_type = convert_resolved_type_id(
         type_engine,
         decl_engine,
         context,
-        &return_type.type_id,
+        return_type.type_id,
         &return_type.span,
     )
     .map_err(|err| vec![err])?;
 
     let span_md_idx = md_mgr.span_to_md(context, span);
     let storage_md_idx = md_mgr.purity_to_md(context, *purity);
+    let name_span_md_idx = md_mgr.fn_name_span_to_md(context, original_name);
     let mut metadata = md_combine(context, &span_md_idx, &storage_md_idx);
+    metadata = md_combine(context, &metadata, &name_span_md_idx);
 
     let decl_index = test_decl_ref.map(|decl_ref| *decl_ref.id());
     if let Some(decl_index) = decl_index {
@@ -569,6 +598,7 @@ fn compile_fn(
         selector,
         *visibility == Visibility::Public,
         is_entry,
+        is_original_entry,
         ast_fn_decl.is_fallback(),
         metadata,
     );
@@ -605,7 +635,7 @@ fn compile_fn(
     // recent instruction was a RET.
     let already_returns = compiler
         .current_block
-        .is_terminated_by_ret_or_revert(context);
+        .is_terminated_by_return_or_revert(context);
     if !already_returns
         && (compiler.current_block.num_instructions(context) > 0
             || compiler.current_block == compiler.function.get_entry_block(context)
@@ -636,23 +666,30 @@ fn compile_abi_method(
     // Use the error from .to_fn_selector_value() if possible, else make an CompileError::Internal.
     let handler = Handler::default();
     let ast_fn_decl = engines.de().get_function(ast_fn_decl);
-    let get_selector_result = ast_fn_decl.to_fn_selector_value(&handler, engines);
-    let (errors, _warnings) = handler.consume();
-    let selector = match get_selector_result.ok() {
-        Some(selector) => selector,
-        None => {
-            return if !errors.is_empty() {
-                Err(vec![errors[0].clone()])
-            } else {
-                Err(vec![CompileError::InternalOwned(
-                    format!(
-                        "Cannot generate selector for ABI method: {}",
-                        ast_fn_decl.name.as_str()
-                    ),
-                    ast_fn_decl.name.span(),
-                )])
-            };
-        }
+
+    // method selector is only used for encoding v0
+    let selector = if context.experimental.new_encoding {
+        None
+    } else {
+        let get_selector_result = ast_fn_decl.to_fn_selector_value(&handler, engines);
+        let (errors, _warnings) = handler.consume();
+        let selector = match get_selector_result.ok() {
+            Some(selector) => selector,
+            None => {
+                return if !errors.is_empty() {
+                    Err(vec![errors[0].clone()])
+                } else {
+                    Err(vec![CompileError::InternalOwned(
+                        format!(
+                            "Cannot generate selector for ABI method: {}",
+                            ast_fn_decl.name.as_str()
+                        ),
+                        ast_fn_decl.name.span(),
+                    )])
+                };
+            }
+        };
+        Some(selector)
     };
 
     compile_fn(
@@ -661,9 +698,12 @@ fn compile_abi_method(
         md_mgr,
         module,
         &ast_fn_decl,
-        // ABI are only entries when the "new encoding" is off
+        &ast_fn_decl.name,
+        // ABI methods are only entries when the "new encoding" is off
         !context.experimental.new_encoding,
-        Some(selector),
+        // ABI methods are always original entries
+        true,
+        selector,
         logged_types_map,
         messages_types_map,
         None,
diff --git a/sway-core/src/ir_generation/const_eval.rs b/sway-core/src/ir_generation/const_eval.rs
index 5509a812f24..ed6b6d70970 100644
--- a/sway-core/src/ir_generation/const_eval.rs
+++ b/sway-core/src/ir_generation/const_eval.rs
@@ -12,7 +12,7 @@ use crate::{
 };
 
 use super::{
-    convert::{convert_literal_to_constant, convert_resolved_typeid},
+    convert::{convert_literal_to_constant, convert_resolved_type_id},
     function::FnCompiler,
     types::*,
 };
@@ -620,9 +620,26 @@ fn const_eval_typed_expr(
                 }
             }
         }
-        ty::TyExpressionVariant::Ref(_) | ty::TyExpressionVariant::Deref(_) => {
+        ty::TyExpressionVariant::Ref(_) => {
             return Err(ConstEvalError::CompileError);
         }
+        // We support *__elem_at(...)
+        ty::TyExpressionVariant::Deref(expr) => {
+            let value = expr
+                .as_intrinsic()
+                .filter(|x| matches!(x.kind, Intrinsic::ElemAt))
+                .ok_or(ConstEvalError::CompileError)
+                .and_then(|kind| const_eval_intrinsic(lookup, known_consts, kind));
+            if let Ok(Some(Constant {
+                value: ConstantValue::Reference(value),
+                ..
+            })) = value
+            {
+                Some(*value.clone())
+            } else {
+                return Err(ConstEvalError::CompileError);
+            }
+        }
         ty::TyExpressionVariant::EnumTag { exp } => {
             let value = const_eval_typed_expr(lookup, known_consts, exp)?.map(|x| x.value);
             if let Some(ConstantValue::Struct(fields)) = value {
@@ -771,9 +788,9 @@ fn const_eval_codeblock(
             ty::TyAstNodeContent::SideEffect(_) => Err(ConstEvalError::CannotBeEvaluatedToConst {
                 span: ast_node.span.clone(),
             }),
-            ty::TyAstNodeContent::Error(_, _) => {
-                unreachable!("error node found when generating IR");
-            }
+            ty::TyAstNodeContent::Error(_, _) => Err(ConstEvalError::CannotBeEvaluatedToConst {
+                span: ast_node.span.clone(),
+            }),
         };
 
         if result.is_err() {
@@ -1036,11 +1053,11 @@ fn const_eval_intrinsic(
         }
         Intrinsic::SizeOfType => {
             let targ = &intrinsic.type_arguments[0];
-            let ir_type = convert_resolved_typeid(
+            let ir_type = convert_resolved_type_id(
                 lookup.engines.te(),
                 lookup.engines.de(),
                 lookup.context,
-                &targ.type_id,
+                targ.type_id,
                 &targ.span,
             )
             .map_err(|_| ConstEvalError::CompileError)?;
@@ -1052,11 +1069,11 @@ fn const_eval_intrinsic(
         Intrinsic::SizeOfVal => {
             let val = &intrinsic.arguments[0];
             let type_id = val.return_type;
-            let ir_type = convert_resolved_typeid(
+            let ir_type = convert_resolved_type_id(
                 lookup.engines.te(),
                 lookup.engines.de(),
                 lookup.context,
-                &type_id,
+                type_id,
                 &val.span,
             )
             .map_err(|_| ConstEvalError::CompileError)?;
@@ -1067,11 +1084,11 @@ fn const_eval_intrinsic(
         }
         Intrinsic::SizeOfStr => {
             let targ = &intrinsic.type_arguments[0];
-            let ir_type = convert_resolved_typeid(
+            let ir_type = convert_resolved_type_id(
                 lookup.engines.te(),
                 lookup.engines.de(),
                 lookup.context,
-                &targ.type_id,
+                targ.type_id,
                 &targ.span,
             )
             .map_err(|_| ConstEvalError::CompileError)?;
@@ -1084,11 +1101,11 @@ fn const_eval_intrinsic(
         }
         Intrinsic::AssertIsStrArray => {
             let targ = &intrinsic.type_arguments[0];
-            let ir_type = convert_resolved_typeid(
+            let ir_type = convert_resolved_type_id(
                 lookup.engines.te(),
                 lookup.engines.de(),
                 lookup.context,
-                &targ.type_id,
+                targ.type_id,
                 &targ.span,
             )
             .map_err(|_| ConstEvalError::CompileError)?;
@@ -1284,6 +1301,68 @@ fn const_eval_intrinsic(
                 value: ConstantValue::RawUntypedSlice(bytes[0..(len as usize)].to_vec()),
             }))
         }
+        Intrinsic::Slice => {
+            let start = args[1].as_uint().expect("Type check allowed non u64") as usize;
+            let end = args[2].as_uint().expect("Type check allowed non u64") as usize;
+
+            match &args[0].value {
+                ConstantValue::Array(elements) => {
+                    let slice = elements
+                        .get(start..end)
+                        .ok_or(ConstEvalError::CompileError)?;
+                    let elem_type = args[0]
+                        .ty
+                        .get_array_elem_type(lookup.context)
+                        .expect("unexpected non array");
+                    Ok(Some(Constant {
+                        ty: Type::get_typed_slice(lookup.context, elem_type),
+                        value: ConstantValue::Slice(slice.to_vec()),
+                    }))
+                }
+                ConstantValue::Reference(r) => match &r.value {
+                    ConstantValue::Slice(elements) => {
+                        let slice = elements
+                            .get(start..end)
+                            .ok_or(ConstEvalError::CompileError)?;
+                        let elem_type = args[0]
+                            .ty
+                            .get_typed_slice_elem_type(lookup.context)
+                            .expect("unexpected non slice");
+                        Ok(Some(Constant {
+                            ty: Type::get_typed_slice(lookup.context, elem_type),
+                            value: ConstantValue::Slice(slice.to_vec()),
+                        }))
+                    }
+                    _ => Err(ConstEvalError::CannotBeEvaluatedToConst {
+                        span: intrinsic.span.clone(),
+                    }),
+                },
+                _ => Err(ConstEvalError::CannotBeEvaluatedToConst {
+                    span: intrinsic.span.clone(),
+                }),
+            }
+        }
+        Intrinsic::ElemAt => {
+            let idx = args[1].as_uint().expect("Type check allowed non u64") as usize;
+
+            match &args[0].value {
+                ConstantValue::Reference(r) => match &r.value {
+                    ConstantValue::Slice(elements) => {
+                        let v = elements[idx].clone();
+                        Ok(Some(Constant {
+                            ty: Type::new_ptr(lookup.context, v.ty),
+                            value: ConstantValue::Reference(Box::new(v)),
+                        }))
+                    }
+                    _ => Err(ConstEvalError::CannotBeEvaluatedToConst {
+                        span: intrinsic.span.clone(),
+                    }),
+                },
+                _ => Err(ConstEvalError::CannotBeEvaluatedToConst {
+                    span: intrinsic.span.clone(),
+                }),
+            }
+        }
     }
 }
 
@@ -1316,18 +1395,17 @@ mod tests {
             },
         );
         let mut md_mgr = MetadataManager::default();
-        let core_lib = namespace::Root::from(namespace::Module {
-            name: Some(sway_types::Ident::new_no_span(
-                "assert_is_constant_test".to_string(),
-            )),
-            ..Default::default()
-        });
+        let mut core_lib = namespace::Root::from(namespace::Module::new(
+            sway_types::Ident::new_no_span("assert_is_constant_test".to_string()),
+            crate::Visibility::Private,
+            None,
+        ));
 
         let r = crate::compile_to_ast(
             &handler,
             &engines,
             std::sync::Arc::from(format!("library; {prefix} fn f() -> u64 {{ {expr}; 0 }}")),
-            core_lib,
+            &mut core_lib,
             None,
             "test",
             None,
diff --git a/sway-core/src/ir_generation/convert.rs b/sway-core/src/ir_generation/convert.rs
index ddacdeab37a..4d0ee1d20c7 100644
--- a/sway-core/src/ir_generation/convert.rs
+++ b/sway-core/src/ir_generation/convert.rs
@@ -52,38 +52,29 @@ pub(super) fn convert_literal_to_constant(
     }
 }
 
-pub(super) fn convert_resolved_typeid(
+pub(super) fn convert_resolved_type_id(
     type_engine: &TypeEngine,
     decl_engine: &DeclEngine,
     context: &mut Context,
-    ast_type: &TypeId,
+    ast_type: TypeId,
     span: &Span,
 ) -> Result<Type, CompileError> {
-    // There's probably a better way to convert TypeError to String, but... we'll use something
-    // other than String eventually?  IrError?
-    convert_resolved_type(
-        type_engine,
-        decl_engine,
-        context,
-        &type_engine
-            .to_typeinfo(*ast_type, span)
-            .map_err(|ty_err| CompileError::InternalOwned(format!("{ty_err:?}"), span.clone()))?,
-        span,
-    )
+    let t = type_engine.get(ast_type);
+    convert_resolved_type_info(type_engine, decl_engine, context, &t, span)
 }
 
 pub(super) fn convert_resolved_typeid_no_span(
     type_engine: &TypeEngine,
     decl_engine: &DeclEngine,
     context: &mut Context,
-    ast_type: &TypeId,
+    ast_type: TypeId,
 ) -> Result<Type, CompileError> {
     let msg = "unknown source location";
     let span = crate::span::Span::from_string(msg.to_string());
-    convert_resolved_typeid(type_engine, decl_engine, context, ast_type, &span)
+    convert_resolved_type_id(type_engine, decl_engine, context, ast_type, &span)
 }
 
-fn convert_resolved_type(
+fn convert_resolved_type_info(
     type_engine: &TypeEngine,
     decl_engine: &DeclEngine,
     context: &mut Context,
@@ -93,10 +84,10 @@ fn convert_resolved_type(
     // A handy macro for rejecting unsupported types.
     macro_rules! reject_type {
         ($name_str:literal) => {{
-            return Err(CompileError::Internal(
-                concat!($name_str, " type cannot be resolved in IR."),
-                span.clone(),
-            ));
+            return Err(CompileError::TypeMustBeKnownAtThisPoint {
+                span: span.clone(),
+                internal: $name_str.into(),
+            });
         }};
     }
 
@@ -131,15 +122,16 @@ fn convert_resolved_type(
             &decl_engine.get_enum(decl_ref).variants,
         )?,
         TypeInfo::Array(elem_type, length) => {
-            let elem_type = convert_resolved_typeid(
+            let elem_type = convert_resolved_type_id(
                 type_engine,
                 decl_engine,
                 context,
-                &elem_type.type_id,
+                elem_type.type_id,
                 span,
             )?;
             Type::new_array(context, elem_type, length.val() as u64)
         }
+
         TypeInfo::Tuple(fields) => {
             if fields.is_empty() {
                 // XXX We've removed Unit from the core compiler, replaced with an empty Tuple.
@@ -154,18 +146,39 @@ fn convert_resolved_type(
         TypeInfo::RawUntypedPtr => Type::get_uint64(context),
         TypeInfo::RawUntypedSlice => Type::get_slice(context),
         TypeInfo::Ptr(_) => Type::get_uint64(context),
-        TypeInfo::Slice(_) => Type::get_slice(context),
         TypeInfo::Alias { ty, .. } => {
-            convert_resolved_typeid(type_engine, decl_engine, context, &ty.type_id, span)?
+            convert_resolved_type_id(type_engine, decl_engine, context, ty.type_id, span)?
+        }
+        // refs to slice are actually fat pointers,
+        // all others refs are thin pointers.
+        TypeInfo::Ref {
+            referenced_type, ..
+        } => {
+            if let Some(slice_elem) = type_engine.get(referenced_type.type_id).as_slice() {
+                let elem_ir_type = convert_resolved_type_id(
+                    type_engine,
+                    decl_engine,
+                    context,
+                    slice_elem.type_id,
+                    span,
+                )?;
+                Type::get_typed_slice(context, elem_ir_type)
+            } else {
+                Type::get_uint64(context)
+            }
         }
-        TypeInfo::Ref { .. } => Type::get_uint64(context),
         TypeInfo::Never => Type::get_never(context),
 
+        // Unsized types
+        TypeInfo::Slice(_) => reject_type!("unsized"),
+
         // Unsupported types which shouldn't exist in the AST after type checking and
         // monomorphisation.
         TypeInfo::Custom { .. } => reject_type!("Custom"),
         TypeInfo::Contract => reject_type!("Contract"),
         TypeInfo::ContractCaller { .. } => reject_type!("ContractCaller"),
+        TypeInfo::UntypedEnum(_) => reject_type!("UntypedEnum"),
+        TypeInfo::UntypedStruct(_) => reject_type!("UntypedStruct"),
         TypeInfo::Unknown => reject_type!("Unknown"),
         TypeInfo::UnknownGeneric { .. } => reject_type!("Generic"),
         TypeInfo::Placeholder(_) => reject_type!("Placeholder"),
diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index af379dd9fda..7c333f55185 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -12,8 +12,8 @@ use crate::{
     },
     language::{
         ty::{
-            self, ProjectionKind, TyConfigurableDecl, TyConstantDecl, TyExpressionVariant,
-            TyStorageField,
+            self, ProjectionKind, TyConfigurableDecl, TyConstantDecl, TyExpression,
+            TyExpressionVariant, TyStorageField,
         },
         *,
     },
@@ -104,6 +104,49 @@ pub(crate) struct FnCompiler<'eng> {
     messages_types_map: HashMap<TypeId, MessageId>,
 }
 
+fn to_constant(_s: &mut FnCompiler<'_>, context: &mut Context, value: u64) -> Value {
+    let needed_size = Constant::new_uint(context, 64, value);
+    Value::new_constant(context, needed_size)
+}
+
+fn save_to_local_return_ptr(
+    s: &mut FnCompiler<'_>,
+    context: &mut Context,
+    value: Value,
+) -> Result<Value, CompileError> {
+    let temp_arg_name = s.lexical_map.insert_anon();
+
+    let value_type = value.get_type(context).unwrap();
+    let local_var = s
+        .function
+        .new_local_var(context, temp_arg_name, value_type, None, false)
+        .map_err(|ir_error| CompileError::InternalOwned(ir_error.to_string(), Span::dummy()))?;
+
+    let local_var_ptr = s.current_block.append(context).get_local(local_var);
+    let _ = s.current_block.append(context).store(local_var_ptr, value);
+    Ok(local_var_ptr)
+}
+
+fn calc_addr_as_ptr(
+    current_block: &mut Block,
+    context: &mut Context,
+    ptr: Value,
+    len: Value,
+    ptr_to: Type,
+) -> Value {
+    assert!(ptr.get_type(context).unwrap().is_ptr(context));
+    assert!(len.get_type(context).unwrap().is_uint64(context));
+
+    let uint64 = Type::get_uint64(context);
+    let ptr = current_block.append(context).ptr_to_int(ptr, uint64);
+    let addr = current_block
+        .append(context)
+        .binary_op(BinaryOpKind::Add, ptr, len);
+
+    let ptr_to = Type::new_ptr(context, ptr_to);
+    current_block.append(context).int_to_ptr(addr, ptr_to)
+}
+
 impl<'eng> FnCompiler<'eng> {
     #[allow(clippy::too_many_arguments)]
     pub(super) fn new(
@@ -229,7 +272,7 @@ impl<'eng> FnCompiler<'eng> {
                     decl_type: "type alias",
                     span: ast_node.span.clone(),
                 }),
-                ty::TyDecl::ImplTrait { .. } => {
+                ty::TyDecl::ImplSelfOrTrait { .. } => {
                     // XXX What if we ignore the trait implementation???  Potentially since
                     // we currently inline everything and below we 'recreate' the functions
                     // lazily as they are called, nothing needs to be done here.  BUT!
@@ -465,14 +508,10 @@ impl<'eng> FnCompiler<'eng> {
                 selector,
                 type_binding: _,
                 call_path_typeid: _,
-                deferred_monomorphization,
                 ..
             } => {
-                if *deferred_monomorphization {
-                    return Err(CompileError::Internal("Trying to compile a deferred function application with deferred monomorphization", name.span()));
-                }
                 if let Some(metadata) = selector {
-                    self.compile_contract_call(
+                    self.compile_contract_call_encoding_v0(
                         context,
                         md_mgr,
                         metadata,
@@ -484,7 +523,14 @@ impl<'eng> FnCompiler<'eng> {
                     )
                 } else {
                     let function_decl = self.engines.de().get_function(fn_ref);
-                    self.compile_fn_call(context, md_mgr, arguments, &function_decl, span_md_idx)
+                    self.compile_fn_call(
+                        context,
+                        md_mgr,
+                        arguments,
+                        &function_decl,
+                        span_md_idx,
+                        name,
+                    )
                 }
             }
             ty::TyExpressionVariant::LazyOperator { op, lhs, rhs } => {
@@ -502,7 +548,7 @@ impl<'eng> FnCompiler<'eng> {
             ty::TyExpressionVariant::Array {
                 elem_type,
                 contents,
-            } => self.compile_array_expr(context, md_mgr, elem_type, contents, span_md_idx),
+            } => self.compile_array_expr(context, md_mgr, *elem_type, contents, span_md_idx),
             ty::TyExpressionVariant::ArrayIndex { prefix, index } => {
                 self.compile_array_index(context, md_mgr, prefix, index, span_md_idx)
             }
@@ -865,11 +911,11 @@ impl<'eng> FnCompiler<'eng> {
             Intrinsic::SizeOfVal => {
                 let exp = &arguments[0];
                 // Compile the expression in case of side-effects but ignore its value.
-                let ir_type = convert_resolved_typeid(
+                let ir_type = convert_resolved_type_id(
                     engines.te(),
                     engines.de(),
                     context,
-                    &exp.return_type,
+                    exp.return_type,
                     &exp.span,
                 )?;
                 self.compile_expression_to_value(context, md_mgr, exp)?;
@@ -878,11 +924,11 @@ impl<'eng> FnCompiler<'eng> {
             }
             Intrinsic::SizeOfType => {
                 let targ = type_arguments[0].clone();
-                let ir_type = convert_resolved_typeid(
+                let ir_type = convert_resolved_type_id(
                     engines.te(),
                     engines.de(),
                     context,
-                    &targ.type_id,
+                    targ.type_id,
                     &targ.span,
                 )?;
                 let val = Constant::get_uint(context, 64, ir_type.size(context).in_bytes());
@@ -890,11 +936,11 @@ impl<'eng> FnCompiler<'eng> {
             }
             Intrinsic::SizeOfStr => {
                 let targ = type_arguments[0].clone();
-                let ir_type = convert_resolved_typeid(
+                let ir_type = convert_resolved_type_id(
                     engines.te(),
                     engines.de(),
                     context,
-                    &targ.type_id,
+                    targ.type_id,
                     &targ.span,
                 )?;
                 let val = Constant::get_uint(
@@ -921,11 +967,11 @@ impl<'eng> FnCompiler<'eng> {
             }
             Intrinsic::AssertIsStrArray => {
                 let targ = type_arguments[0].clone();
-                let ir_type = convert_resolved_typeid(
+                let ir_type = convert_resolved_type_id(
                     engines.te(),
                     engines.de(),
                     context,
-                    &targ.type_id,
+                    targ.type_id,
                     &targ.span,
                 )?;
                 match ir_type.get_content(context) {
@@ -998,11 +1044,11 @@ impl<'eng> FnCompiler<'eng> {
 
                 // Get the target type from the type argument provided
                 let target_type = &type_arguments[0];
-                let target_ir_type = convert_resolved_typeid(
+                let target_ir_type = convert_resolved_type_id(
                     engines.te(),
                     engines.de(),
                     context,
-                    &target_type.type_id,
+                    target_type.type_id,
                     &target_type.span,
                 )?;
 
@@ -1283,11 +1329,11 @@ impl<'eng> FnCompiler<'eng> {
                 };
 
                 let len = type_arguments[0].clone();
-                let ir_type = convert_resolved_typeid(
+                let ir_type = convert_resolved_type_id(
                     engines.te(),
                     engines.de(),
                     context,
-                    &len.type_id,
+                    len.type_id,
                     &len.span,
                 )?;
                 let len_value = Constant::get_uint(context, 64, ir_type.size(context).in_bytes());
@@ -1583,26 +1629,6 @@ impl<'eng> FnCompiler<'eng> {
                         .binary_op(BinaryOpKind::Add, len, step)
                 }
 
-                fn calc_addr_as_ptr(
-                    current_block: &mut Block,
-                    context: &mut Context,
-                    ptr: Value,
-                    len: Value,
-                    ptr_to: Type,
-                ) -> Value {
-                    assert!(ptr.get_type(context).unwrap().is_ptr(context));
-                    assert!(len.get_type(context).unwrap().is_uint64(context));
-
-                    let uint64 = Type::get_uint64(context);
-                    let ptr = current_block.append(context).ptr_to_int(ptr, uint64);
-                    let addr = current_block
-                        .append(context)
-                        .binary_op(BinaryOpKind::Add, ptr, len);
-
-                    let ptr_to = Type::new_ptr(context, ptr_to);
-                    current_block.append(context).int_to_ptr(addr, ptr_to)
-                }
-
                 fn append_with_store(
                     current_block: &mut Block,
                     context: &mut Context,
@@ -1665,27 +1691,6 @@ impl<'eng> FnCompiler<'eng> {
                         .binary_op(BinaryOpKind::Add, len, step)
                 }
 
-                fn save_to_local_return_ptr(
-                    s: &mut FnCompiler<'_>,
-                    context: &mut Context,
-                    value: Value,
-                ) -> Result<Value, CompileError> {
-                    let temp_arg_name = s.lexical_map.insert_anon();
-
-                    let value_type = value.get_type(context).unwrap();
-                    let local_var = s
-                        .function
-                        .new_local_var(context, temp_arg_name, value_type, None, false)
-                        .map_err(|ir_error| {
-                            CompileError::InternalOwned(ir_error.to_string(), Span::dummy())
-                        })?;
-
-                    let local_var_ptr = s.current_block.append(context).get_local(local_var);
-                    let _ = s.current_block.append(context).store(local_var_ptr, value);
-
-                    Ok(local_var_ptr)
-                }
-
                 fn append_with_memcpy(
                     s: &mut FnCompiler<'_>,
                     context: &mut Context,
@@ -1721,6 +1726,215 @@ impl<'eng> FnCompiler<'eng> {
                     Ok(increase_len(&mut s.current_block, context, len, 8 - offset))
                 }
 
+                fn grow_if_needed(
+                    s: &mut FnCompiler<'_>,
+                    context: &mut Context,
+                    ptr: Value,
+                    cap: Value,
+                    len: Value,
+                    needed_size: Value,
+                ) -> (Value, Value) {
+                    assert!(ptr.get_type(context).unwrap().is_ptr(context));
+                    assert!(cap.get_type(context).unwrap().is_uint64(context));
+
+                    let ptr_u8 = Type::new_ptr(context, Type::get_uint8(context));
+
+                    // merge block has two arguments: ptr, cap
+                    let merge_block = s.function.create_block(context, None);
+                    let merge_block_ptr = Value::new_argument(
+                        context,
+                        BlockArgument {
+                            block: merge_block,
+                            idx: 0,
+                            ty: ptr_u8,
+                        },
+                    );
+                    merge_block.add_arg(context, merge_block_ptr);
+                    let merge_block_cap = Value::new_argument(
+                        context,
+                        BlockArgument {
+                            block: merge_block,
+                            idx: 1,
+                            ty: Type::get_uint64(context),
+                        },
+                    );
+                    merge_block.add_arg(context, merge_block_cap);
+
+                    let true_block_begin = s.function.create_block(context, None);
+                    let false_block_begin = s.function.create_block(context, None);
+
+                    // if len + needed_size > cap
+                    let needed_cap = s.current_block.append(context).binary_op(
+                        BinaryOpKind::Add,
+                        len,
+                        needed_size,
+                    );
+                    let needs_realloc = s.current_block.append(context).cmp(
+                        Predicate::GreaterThan,
+                        needed_cap,
+                        cap,
+                    );
+                    s.current_block.append(context).conditional_branch(
+                        needs_realloc,
+                        true_block_begin,
+                        false_block_begin,
+                        vec![],
+                        vec![],
+                    );
+
+                    // needs realloc block
+                    // new_cap = cap * 2
+                    // aloc new_cap
+                    // mcp hp old_ptr len
+                    // hp: ptr u8
+                    s.current_block = true_block_begin;
+                    let u8 = Type::get_uint8(context);
+                    let ptr_u8 = Type::new_ptr(context, u8);
+
+                    let two = Constant::new_uint(context, 64, 2);
+                    let two = Value::new_constant(context, two);
+                    let new_cap =
+                        s.current_block
+                            .append(context)
+                            .binary_op(BinaryOpKind::Mul, cap, two);
+
+                    let new_ptr = s.current_block.append(context).asm_block(
+                        vec![
+                            AsmArg {
+                                name: Ident::new_no_span("new_cap".into()),
+                                initializer: Some(new_cap),
+                            },
+                            AsmArg {
+                                name: Ident::new_no_span("old_ptr".into()),
+                                initializer: Some(ptr),
+                            },
+                            AsmArg {
+                                name: Ident::new_no_span("len".into()),
+                                initializer: Some(len),
+                            },
+                        ],
+                        vec![
+                            AsmInstruction {
+                                op_name: Ident::new_no_span("aloc".into()),
+                                args: vec![Ident::new_no_span("new_cap".into())],
+                                immediate: None,
+                                metadata: None,
+                            },
+                            AsmInstruction {
+                                op_name: Ident::new_no_span("mcp".into()),
+                                args: vec![
+                                    Ident::new_no_span("hp".into()),
+                                    Ident::new_no_span("old_ptr".into()),
+                                    Ident::new_no_span("len".into()),
+                                ],
+                                immediate: None,
+                                metadata: None,
+                            },
+                        ],
+                        ptr_u8,
+                        Some(Ident::new_no_span("hp".into())),
+                    );
+
+                    s.current_block
+                        .append(context)
+                        .branch(merge_block, vec![new_ptr, new_cap]);
+
+                    // dont need realloc block
+                    s.current_block = false_block_begin;
+                    s.current_block
+                        .append(context)
+                        .branch(merge_block, vec![ptr, cap]);
+
+                    s.current_block = merge_block;
+
+                    assert!(merge_block_ptr.get_type(context).unwrap().is_ptr(context));
+                    assert!(merge_block_cap
+                        .get_type(context)
+                        .unwrap()
+                        .is_uint64(context));
+
+                    (merge_block_ptr, merge_block_cap)
+                }
+
+                // Grow the buffer if needed
+                let (ptr, cap) = match &*item_type {
+                    TypeInfo::Boolean => {
+                        let needed_size = to_constant(self, context, 1);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::UnsignedInteger(IntegerBits::Eight) => {
+                        let needed_size = to_constant(self, context, 1);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::UnsignedInteger(IntegerBits::Sixteen) => {
+                        let needed_size = to_constant(self, context, 2);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::UnsignedInteger(IntegerBits::ThirtyTwo) => {
+                        let needed_size = to_constant(self, context, 4);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::UnsignedInteger(IntegerBits::SixtyFour) => {
+                        let needed_size = to_constant(self, context, 8);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::UnsignedInteger(IntegerBits::V256) | TypeInfo::B256 => {
+                        let needed_size = to_constant(self, context, 32);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::StringArray(string_len) => {
+                        let needed_size = to_constant(self, context, string_len.val() as u64);
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    TypeInfo::StringSlice | TypeInfo::RawUntypedSlice => {
+                        let uint64 = Type::get_uint64(context);
+                        let u64_u64_type = Type::new_struct(context, vec![uint64, uint64]);
+
+                        // convert "item" to { u64, u64 }
+                        let item = self.current_block.append(context).asm_block(
+                            vec![AsmArg {
+                                name: Ident::new_no_span("item".into()),
+                                initializer: Some(item),
+                            }],
+                            vec![],
+                            u64_u64_type,
+                            Some(Ident::new_no_span("item".into())),
+                        );
+
+                        // save item to local _anon
+                        let name = self.lexical_map.insert_anon();
+                        let item_local = self
+                            .function
+                            .new_local_var(context, name, u64_u64_type, None, false)
+                            .map_err(|ir_error| {
+                                CompileError::InternalOwned(ir_error.to_string(), Span::dummy())
+                            })?;
+                        let ptr_to_local_item =
+                            self.current_block.append(context).get_local(item_local);
+                        self.current_block
+                            .append(context)
+                            .store(ptr_to_local_item, item);
+
+                        // _anon.1 = len
+                        let needed_size = self.current_block.append(context).get_elem_ptr_with_idx(
+                            ptr_to_local_item,
+                            uint64,
+                            1,
+                        );
+                        let needed_size = self.current_block.append(context).load(needed_size);
+                        let eight = to_constant(self, context, 8);
+                        let needed_size = self.current_block.append(context).binary_op(
+                            BinaryOpKind::Add,
+                            needed_size,
+                            eight,
+                        );
+
+                        grow_if_needed(self, context, ptr, cap, len, needed_size)
+                    }
+                    _ => return Err(CompileError::EncodingUnsupportedType { span: item_span }),
+                };
+
+                // Append the value into the buffer
                 let new_len = match &*item_type {
                     TypeInfo::Boolean => {
                         assert!(item.get_type(context).unwrap().is_bool(context));
@@ -1954,9 +2168,211 @@ impl<'eng> FnCompiler<'eng> {
 
                 Ok(TerminatorValue::new(buffer, context))
             }
+            Intrinsic::Slice => self.compile_intrinsic_slice(arguments, context, md_mgr),
+            Intrinsic::ElemAt => self.compile_intrinsic_elem_at(arguments, context, md_mgr),
         }
     }
 
+    fn ptr_to_first_element(
+        &mut self,
+        context: &mut Context,
+        first_argument_expr: &TyExpression,
+        first_argument_value: Value,
+        _md_mgr: &mut MetadataManager,
+    ) -> Result<(Value, TypeId), CompileError> {
+        let te = self.engines.te();
+
+        let err = CompileError::TypeArgumentsNotAllowed {
+            span: first_argument_expr.span.clone(),
+        };
+
+        let first_argument_value = save_to_local_return_ptr(self, context, first_argument_value)?;
+
+        let ptr_arg = AsmArg {
+            name: Ident::new_no_span("ptr".into()),
+            initializer: Some(first_argument_value),
+        };
+
+        let ptr_out_arg = AsmArg {
+            name: Ident::new_no_span("ptr_out".into()),
+            initializer: Some(first_argument_value),
+        };
+
+        let return_type = Type::get_uint64(context);
+        let ptr_to_first_element = self.current_block.append(context).asm_block(
+            vec![ptr_arg, ptr_out_arg],
+            vec![AsmInstruction::lw_no_span("ptr_out", "ptr", "i0")],
+            return_type,
+            Some(Ident::new_no_span("ptr_out".into())),
+        );
+
+        match &*te.get(first_argument_expr.return_type) {
+            TypeInfo::Ref {
+                referenced_type, ..
+            } => match &*te.get(referenced_type.type_id) {
+                TypeInfo::Array(elem_ty, _) | TypeInfo::Slice(elem_ty) => {
+                    Ok((ptr_to_first_element, elem_ty.type_id))
+                }
+                _ => Err(err),
+            },
+            _ => Err(err),
+        }
+    }
+
+    fn advance_ptr_n_elements(
+        &mut self,
+        context: &mut Context,
+        first_argument_expr: &TyExpression,
+        ptr: Value,
+        elem_type_id: TypeId,
+        idx: Value,
+    ) -> Result<(Value, Type), CompileError> {
+        let te = self.engines.te();
+        let de = self.engines.de();
+
+        let elem_ir_type = convert_resolved_type_id(
+            te,
+            de,
+            context,
+            elem_type_id,
+            &first_argument_expr.span.clone(),
+        )?;
+        let elem_ir_type_size = elem_ir_type.size(context);
+        let elem_ir_type_size = to_constant(self, context, elem_ir_type_size.in_bytes());
+        let elem_ir_type_size_arg = AsmArg {
+            name: Ident::new_no_span("elem_ir_type_size".into()),
+            initializer: Some(elem_ir_type_size),
+        };
+
+        let offset_temp_arg = AsmArg {
+            name: Ident::new_no_span("offset_temp".into()),
+            initializer: None,
+        };
+
+        let idx_arg = AsmArg {
+            name: Ident::new_no_span("idx".into()),
+            initializer: Some(idx),
+        };
+
+        let ptr_arg = AsmArg {
+            name: Ident::new_no_span("ptr".into()),
+            initializer: Some(ptr),
+        };
+
+        let ptr_out_arg = AsmArg {
+            name: Ident::new_no_span("ptr_out".into()),
+            initializer: Some(ptr),
+        };
+
+        let return_type = Type::get_uint64(context);
+        let ptr = self.current_block.append(context).asm_block(
+            vec![
+                idx_arg,
+                elem_ir_type_size_arg,
+                ptr_arg,
+                offset_temp_arg,
+                ptr_out_arg,
+            ],
+            vec![
+                AsmInstruction::mul_no_span("offset_temp", "idx", "elem_ir_type_size"),
+                AsmInstruction::add_no_span("ptr_out", "ptr", "offset_temp"),
+            ],
+            return_type,
+            Some(Ident::new_no_span("ptr".into())),
+        );
+
+        Ok((ptr, elem_ir_type))
+    }
+
+    fn compile_intrinsic_elem_at(
+        &mut self,
+        arguments: &[ty::TyExpression],
+        context: &mut Context,
+        md_mgr: &mut MetadataManager,
+    ) -> Result<TerminatorValue, CompileError> {
+        assert!(arguments.len() == 2);
+
+        let first_argument_expr = &arguments[0];
+        let first_argument_value = return_on_termination_or_extract!(
+            self.compile_expression_to_value(context, md_mgr, first_argument_expr)?
+        );
+        let (ptr_to_first_elem, elem_type_id) =
+            self.ptr_to_first_element(context, first_argument_expr, first_argument_value, md_mgr)?;
+
+        let idx = &arguments[1];
+        let idx = return_on_termination_or_extract!(
+            self.compile_expression_to_value(context, md_mgr, idx)?
+        );
+        let (ptr_to_elem, _) = self.advance_ptr_n_elements(
+            context,
+            first_argument_expr,
+            ptr_to_first_elem,
+            elem_type_id,
+            idx,
+        )?;
+
+        Ok(TerminatorValue::new(ptr_to_elem, context))
+    }
+
+    fn compile_intrinsic_slice(
+        &mut self,
+        arguments: &[ty::TyExpression],
+        context: &mut Context,
+        md_mgr: &mut MetadataManager,
+    ) -> Result<TerminatorValue, CompileError> {
+        assert!(arguments.len() == 3);
+
+        let first_argument_expr = &arguments[0];
+        let first_argument_value = return_on_termination_or_extract!(
+            self.compile_expression_to_value(context, md_mgr, first_argument_expr)?
+        );
+        let (ptr_to_first_elem, elem_type_id) =
+            self.ptr_to_first_element(context, first_argument_expr, first_argument_value, md_mgr)?;
+
+        let start = &arguments[1];
+        let start = return_on_termination_or_extract!(
+            self.compile_expression_to_value(context, md_mgr, start)?
+        );
+        let (ptr_to_elem, elem_ir_type) = self.advance_ptr_n_elements(
+            context,
+            first_argument_expr,
+            ptr_to_first_elem,
+            elem_type_id,
+            start,
+        )?;
+
+        let end = &arguments[2];
+        let end = return_on_termination_or_extract!(
+            self.compile_expression_to_value(context, md_mgr, end)?
+        );
+
+        let slice_len = self
+            .current_block
+            .append(context)
+            .binary_op(BinaryOpKind::Sub, end, start);
+
+        // compile the slice together
+        let uint64 = Type::get_uint64(context);
+        let return_type = Type::get_typed_slice(context, elem_ir_type);
+        let slice_as_tuple = self.compile_tuple_from_values(
+            context,
+            vec![ptr_to_elem, slice_len],
+            vec![uint64, uint64],
+            None,
+        )?;
+        let slice = self.current_block.append(context).asm_block(
+            vec![AsmArg {
+                name: Ident::new_no_span("s".into()),
+                initializer: Some(slice_as_tuple),
+            }],
+            vec![],
+            return_type,
+            Some(Ident::new_no_span("s".into())),
+        );
+
+        Ok(TerminatorValue::new(slice, context))
+    }
+
     fn compile_return(
         &mut self,
         context: &mut Context,
@@ -2085,11 +2501,11 @@ impl<'eng> FnCompiler<'eng> {
             )),
         }?;
 
-        let referenced_ir_type = convert_resolved_typeid(
+        let referenced_ir_type = convert_resolved_type_id(
             self.engines.te(),
             self.engines.de(),
             context,
-            &referenced_ast_type,
+            referenced_ast_type,
             &ast_expr.span.clone(),
         )?;
 
@@ -2158,7 +2574,7 @@ impl<'eng> FnCompiler<'eng> {
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn compile_contract_call(
+    fn compile_contract_call_encoding_v0(
         &mut self,
         context: &mut Context,
         md_mgr: &mut MetadataManager,
@@ -2317,7 +2733,8 @@ impl<'eng> FnCompiler<'eng> {
             .add_metadatum(context, span_md_idx);
 
         // Convert selector to U64 and then insert it
-        let sel = call_params.func_selector;
+        assert!(!context.experimental.new_encoding);
+        let sel = call_params.func_selector.as_ref().unwrap();
         let sel_val = convert_literal_to_value(
             context,
             &Literal::U64(
@@ -2414,7 +2831,7 @@ impl<'eng> FnCompiler<'eng> {
             self.engines.te(),
             self.engines.de(),
             context,
-            &ast_return_type,
+            ast_return_type,
         )?;
         let ret_is_copy_type = self
             .engines
@@ -2458,6 +2875,7 @@ impl<'eng> FnCompiler<'eng> {
         ast_args: &[(Ident, ty::TyExpression)],
         callee: &ty::TyFunctionDecl,
         span_md_idx: Option<MetadataIndex>,
+        call_path: &CallPath,
     ) -> Result<TerminatorValue, CompileError> {
         let new_callee = self.cache.ty_function_decl_to_unique_function(
             self.engines,
@@ -2483,11 +2901,14 @@ impl<'eng> FnCompiler<'eng> {
             args.push(arg);
         }
 
+        let call_path_span_md_idx = md_mgr.fn_call_path_span_to_md(context, call_path);
+        let md_idx = combine(context, &span_md_idx, &call_path_span_md_idx);
+
         let val = self
             .current_block
             .append(context)
             .call(new_callee, &args)
-            .add_metadatum(context, span_md_idx);
+            .add_metadatum(context, md_idx);
 
         Ok(TerminatorValue::new(val, context))
     }
@@ -2563,7 +2984,7 @@ impl<'eng> FnCompiler<'eng> {
                 self.engines.te(),
                 self.engines.de(),
                 context,
-                &return_type,
+                return_type,
             )
             .unwrap_or_else(|_| Type::get_unit(context));
             let merge_val_arg_idx = merge_block.new_arg(context, return_type);
@@ -2591,11 +3012,11 @@ impl<'eng> FnCompiler<'eng> {
         variant: &ty::TyEnumVariant,
     ) -> Result<TerminatorValue, CompileError> {
         // Retrieve the type info for the enum.
-        let enum_type = match convert_resolved_typeid(
+        let enum_type = match convert_resolved_type_id(
             self.engines.te(),
             self.engines.de(),
             context,
-            &exp.return_type,
+            exp.return_type,
             &exp.span,
         )? {
             ty if ty.is_struct(context) => ty,
@@ -2682,6 +3103,7 @@ impl<'eng> FnCompiler<'eng> {
         let cond_value = return_on_termination_or_extract!(
             self.compile_expression_to_value(context, md_mgr, condition)?
         );
+        let cond_end_block = self.current_block;
 
         // Create the break block.
         let break_block = self
@@ -2724,8 +3146,8 @@ impl<'eng> FnCompiler<'eng> {
         // Add an unconditional jump from the break block to the final block.
         break_block.append(context).branch(final_block, vec![]);
 
-        // Add conditional jumps from the conditional block to the body block or the final block.
-        cond_block.append(context).conditional_branch(
+        // Add conditional jumps from the end of the condition to the body block or the final block.
+        cond_end_block.append(context).conditional_branch(
             cond_value,
             body_block,
             final_block,
@@ -2871,11 +3293,11 @@ impl<'eng> FnCompiler<'eng> {
         // accessed and isn't present in the environment.
         let init_val = self.compile_expression_to_value(context, md_mgr, body);
 
-        let return_type = convert_resolved_typeid(
+        let return_type = convert_resolved_type_id(
             self.engines.te(),
             self.engines.de(),
             context,
-            &body.return_type,
+            body.return_type,
             &body.span,
         )?;
 
@@ -2950,11 +3372,11 @@ impl<'eng> FnCompiler<'eng> {
                     .lexical_map
                     .insert(call_path.suffix.as_str().to_owned());
 
-                let return_type = convert_resolved_typeid(
+                let return_type = convert_resolved_type_id(
                     self.engines.te(),
                     self.engines.de(),
                     context,
-                    &value.return_type,
+                    value.return_type,
                     &value.span,
                 )?;
 
@@ -3155,7 +3577,7 @@ impl<'eng> FnCompiler<'eng> {
         &mut self,
         context: &mut Context,
         md_mgr: &mut MetadataManager,
-        elem_type: &TypeId,
+        elem_type: TypeId,
         contents: &[ty::TyExpression],
         span_md_idx: Option<MetadataIndex>,
     ) -> Result<TerminatorValue, CompileError> {
@@ -3401,7 +3823,7 @@ impl<'eng> FnCompiler<'eng> {
                 self.engines.te(),
                 self.engines.de(),
                 context,
-                &struct_field.value.return_type,
+                struct_field.value.return_type,
             )?;
             field_types.push(field_type);
         }
@@ -3480,11 +3902,11 @@ impl<'eng> FnCompiler<'eng> {
                 )
             })?;
 
-        let field_type = convert_resolved_typeid(
+        let field_type = convert_resolved_type_id(
             self.engines.te(),
             self.engines.de(),
             context,
-            &field_type_id,
+            field_type_id,
             &ast_field.span,
         )?;
 
@@ -3639,7 +4061,7 @@ impl<'eng> FnCompiler<'eng> {
                     self.engines.te(),
                     self.engines.de(),
                     context,
-                    &field_expr.return_type,
+                    field_expr.return_type,
                 )?;
                 init_values.push(init_value);
                 init_types.push(init_type);
@@ -3663,11 +4085,11 @@ impl<'eng> FnCompiler<'eng> {
         let tuple_value = return_on_termination_or_extract!(
             self.compile_expression_to_ptr(context, md_mgr, tuple)?
         );
-        let tuple_type = convert_resolved_typeid(
+        let tuple_type = convert_resolved_type_id(
             self.engines.te(),
             self.engines.de(),
             context,
-            &tuple_type,
+            tuple_type,
             &span,
         )?;
 
@@ -3714,7 +4136,7 @@ impl<'eng> FnCompiler<'eng> {
             self.engines.te(),
             self.engines.de(),
             context,
-            &base_type,
+            base_type,
         )?;
 
         // Do the actual work. This is a recursive function because we want to drill down
@@ -3819,7 +4241,7 @@ impl<'eng> FnCompiler<'eng> {
             self.engines.te(),
             self.engines.de(),
             context,
-            &return_type,
+            return_type,
         )?;
         let val = self
             .current_block
diff --git a/sway-core/src/ir_generation/purity.rs b/sway-core/src/ir_generation/purity.rs
index 487a982c551..79d61df830f 100644
--- a/sway-core/src/ir_generation/purity.rs
+++ b/sway-core/src/ir_generation/purity.rs
@@ -3,11 +3,14 @@ use crate::{
         promote_purity,
         Purity::{self, *},
     },
-    metadata::{MetadataManager, StorageOperation},
+    metadata::MetadataManager,
 };
 
-use sway_error::warning::{CompileWarning, Warning};
 use sway_error::{error::CompileError, handler::Handler};
+use sway_error::{
+    error::StorageAccess,
+    warning::{CompileWarning, Warning},
+};
 use sway_ir::{Context, FuelVmInstruction, Function, InstOp};
 use sway_types::span::Span;
 
@@ -34,8 +37,11 @@ pub(crate) fn check_function_purity(
     // Iterate for each instruction in the function and gather whether we have read and/or
     // write storage operations:
     // - via the storage IR instructions,
-    // - via ASM blocks with storage VM instructions or
+    // - via ASM blocks with storage VM instructions, or
     // - via calls into functions with the above.
+    let attributed_purity = md_mgr.md_to_purity(context, function.get_metadata(context));
+
+    let mut storage_access_violations = vec![];
     let (reads, writes) = function.instruction_iter(context).fold(
         (false, false),
         |(reads, writes), (_block, ins_value)| {
@@ -43,27 +49,53 @@ pub(crate) fn check_function_purity(
                 .get_instruction(context)
                 .map(|instruction| {
                     match &instruction.op {
-                        InstOp::FuelVm(FuelVmInstruction::StateLoadQuadWord { .. })
-                        | InstOp::FuelVm(FuelVmInstruction::StateLoadWord(_)) => (true, writes),
+                        InstOp::FuelVm(inst) if is_store_access_fuel_vm_instruction(inst) => {
+                            let storage_access = store_access_fuel_vm_instruction_to_storage_access(inst);
+                            if violates_purity(&storage_access, &attributed_purity) {
+                                // When compiling Sway code, the only way to get FuelVM store access instructions in the IR
+                                // is via store access intrinsics. So we know that the span stored in the metadata will be
+                                // the intrinsic's call span which is suitable for error reporting.
+                                let intrinsic_call_span = md_mgr.md_to_span(context, ins_value.get_metadata(context)).unwrap_or(Span::dummy());
+                                storage_access_violations.push((intrinsic_call_span, storage_access));
+                            }
 
-                        InstOp::FuelVm(FuelVmInstruction::StateClear { .. })
-                        | InstOp::FuelVm(FuelVmInstruction::StateStoreQuadWord { .. })
-                        | InstOp::FuelVm(FuelVmInstruction::StateStoreWord { .. }) => (reads, true),
+                            match inst {
+                                FuelVmInstruction::StateLoadQuadWord { .. }
+                                | FuelVmInstruction::StateLoadWord(_) => (true, writes),
+                                FuelVmInstruction::StateClear { .. }
+                                | FuelVmInstruction::StateStoreQuadWord { .. }
+                                | FuelVmInstruction::StateStoreWord { .. } => (reads, true),
+                                _ => unreachable!("The FuelVM instruction is checked to be a store access instruction."),
+                            }
+                        }
 
                         // Iterate for and check each instruction in the ASM block.
                         InstOp::AsmBlock(asm_block, _args) => asm_block.body.iter().fold(
                             (reads, writes),
-                            |(reads, writes), asm_op| match asm_op.op_name.as_str() {
-                                "scwq" | "srw" | "srwq" => (true, writes),
-                                "sww" | "swwq" => (reads, true),
-                                _ => (reads, writes),
-                            },
+                            |(reads, writes), asm_op| {
+                                let inst = asm_op.op_name.as_str();
+                                if is_store_access_asm_instruction(inst) {
+                                    let storage_access = store_access_asm_instruction_to_storage_access(inst);
+                                    if violates_purity(&storage_access, &attributed_purity) {
+                                        let asm_inst_span = md_mgr.md_to_span(context, asm_op.metadata).unwrap_or(Span::dummy());
+                                        storage_access_violations.push((asm_inst_span, storage_access));
+                                    }
+
+                                    match inst {
+                                        "srw" | "srwq" => (true, writes),
+                                        "scwq" | "sww" | "swwq" => (reads, true),
+                                        _ => unreachable!("The ASM instruction is checked to be a store access instruction."),
+                                    }
+                                } else {
+                                    (reads, writes)
+                                }
+                            }
                         ),
 
                         // Recurse to find the called function purity.  Use memoisation to
                         // avoid redoing work.
                         InstOp::Call(callee, _args) => {
-                            let (called_fn_reads, called_fn_writes) =
+                            let (callee_reads, callee_writes) =
                                 env.memos.get(callee).copied().unwrap_or_else(|| {
                                     let r_w = check_function_purity(
                                         handler, env, context, md_mgr, callee,
@@ -71,7 +103,14 @@ pub(crate) fn check_function_purity(
                                     env.memos.insert(*callee, r_w);
                                     r_w
                                 });
-                            (reads || called_fn_reads, writes || called_fn_writes)
+                            if callee_reads || callee_writes {
+                                let callee_span = md_mgr.md_to_fn_call_path_span(context, ins_value.get_metadata(context)).unwrap_or(Span::dummy());
+                                let storage_access = StorageAccess::ImpureFunctionCall(callee_span.clone(), callee_reads, callee_writes);
+                                if violates_purity(&storage_access, &attributed_purity) {
+                                    storage_access_violations.push((callee_span, storage_access));
+                                }
+                            }
+                            (reads || callee_reads, writes || callee_writes)
                         }
 
                         _otherwise => (reads, writes),
@@ -81,19 +120,21 @@ pub(crate) fn check_function_purity(
         },
     );
 
-    let attributed_purity = md_mgr.md_to_storage_op(context, function.get_metadata(context));
-    let span = md_mgr
-        .md_to_span(context, function.get_metadata(context))
-        .unwrap_or_else(Span::dummy);
-
     // Simple closures for each of the error types.
-    let error = |span, storage_op, existing, needed| {
-        handler.emit_err(CompileError::ImpureInPureContext {
-            storage_op,
-            attrs: promote_purity(existing, needed).to_attribute_syntax(),
-            span,
-        });
+    let error = |span: Span, needed| {
+        // We don't emit errors on the generated `__entry` function
+        // but do on the original entry functions and all other functions.
+        if !function.is_entry(context) || function.is_original_entry(context) {
+            handler.emit_err(CompileError::StorageAccessMismatched {
+                span,
+                is_pure: matches!(attributed_purity, Pure),
+                suggested_attributes: promote_purity(attributed_purity, needed)
+                    .to_attribute_syntax(),
+                storage_access_violations,
+            });
+        }
     };
+
     let warn = |span, purity: Purity| {
         // Do not warn on generated code
         if span != Span::dummy() {
@@ -106,28 +147,79 @@ pub(crate) fn check_function_purity(
         }
     };
 
+    let span = md_mgr
+        .md_to_fn_name_span(context, function.get_metadata(context))
+        .unwrap_or_else(Span::dummy);
+
     match (attributed_purity, reads, writes) {
         // Has no attributes but needs some.
-        (None, true, false) => error(span, "read", Pure, Reads),
-        (None, false, true) => error(span, "write", Pure, Writes),
-        (None, true, true) => error(span, "read & write", Pure, ReadsWrites),
+        (Pure, true, false) => error(span, Reads),
+        (Pure, false, true) => error(span, Writes),
+        (Pure, true, true) => error(span, ReadsWrites),
 
-        // Or the attribute must match the behaviour.
-        (Some(StorageOperation::Reads), _, true) => error(span, "write", Reads, Writes),
+        // Or the attribute must match the behavior.
+        (Reads, _, true) => error(span, Writes),
 
         // Or we have unneeded attributes.
-        (Some(StorageOperation::ReadsWrites), false, true) => warn(span, Reads),
-        (Some(StorageOperation::ReadsWrites), true, false) => warn(span, Writes),
-        (Some(StorageOperation::ReadsWrites), false, false) => warn(span, ReadsWrites),
-        (Some(StorageOperation::Reads), false, false) => warn(span, Reads),
-        (Some(StorageOperation::Writes), _, false) => warn(span, Writes),
-
-        // Attributes and effects are in total agreement
-        (None, false, false)
-        | (Some(StorageOperation::Reads), true, false)
-        | (Some(StorageOperation::Writes), _, true) // storage(write) allows reading as well 
-        | (Some(StorageOperation::ReadsWrites), true, true) => (),
+        (ReadsWrites, false, true) => warn(span, Reads),
+        (ReadsWrites, true, false) => warn(span, Writes),
+        (ReadsWrites, false, false) => warn(span, ReadsWrites),
+        (Reads, false, false) => warn(span, Reads),
+        (Writes, _, false) => warn(span, Writes),
+
+        // Attributes and effects are in total agreement.
+        (Pure, false, false)
+        | (Reads, true, false)
+        | (Writes, _, true) // storage(write) allows reading as well 
+        | (ReadsWrites, true, true) => (),
     };
 
     (reads, writes)
 }
+
+fn is_store_access_fuel_vm_instruction(inst: &FuelVmInstruction) -> bool {
+    matches!(
+        inst,
+        FuelVmInstruction::StateLoadWord(_)
+            | FuelVmInstruction::StateLoadQuadWord { .. }
+            | FuelVmInstruction::StateClear { .. }
+            | FuelVmInstruction::StateStoreWord { .. }
+            | FuelVmInstruction::StateStoreQuadWord { .. }
+    )
+}
+
+fn store_access_fuel_vm_instruction_to_storage_access(inst: &FuelVmInstruction) -> StorageAccess {
+    match inst {
+        FuelVmInstruction::StateLoadWord(_) => StorageAccess::ReadWord,
+        FuelVmInstruction::StateLoadQuadWord { .. } => StorageAccess::ReadSlots,
+        FuelVmInstruction::StateClear { .. } => StorageAccess::Clear,
+        FuelVmInstruction::StateStoreWord { .. } => StorageAccess::WriteWord,
+        FuelVmInstruction::StateStoreQuadWord { .. } => StorageAccess::WriteSlots,
+        _ => panic!("The FuelVM instruction is not a store access instruction."),
+    }
+}
+
+fn is_store_access_asm_instruction(inst: &str) -> bool {
+    matches!(inst, "srw" | "srwq" | "scwq" | "sww" | "swwq")
+}
+
+fn store_access_asm_instruction_to_storage_access(inst: &str) -> StorageAccess {
+    match inst {
+        "srw" => StorageAccess::ReadWord,
+        "srwq" => StorageAccess::ReadSlots,
+        "scwq" => StorageAccess::Clear,
+        "sww" => StorageAccess::WriteWord,
+        "swwq" => StorageAccess::WriteSlots,
+        _ => panic!("The ASM instruction \"{inst}\" is not a store access instruction."),
+    }
+}
+
+/// Returns true if the `storage_access` violates the given expected `purity`.
+fn violates_purity(storage_access: &StorageAccess, purity: &Purity) -> bool {
+    match purity {
+        Pure => true,
+        Reads => storage_access.is_write(),
+        Writes => false,
+        ReadsWrites => false,
+    }
+}
diff --git a/sway-core/src/ir_generation/types.rs b/sway-core/src/ir_generation/types.rs
index 6d549c7f890..63487dd6b78 100644
--- a/sway-core/src/ir_generation/types.rs
+++ b/sway-core/src/ir_generation/types.rs
@@ -26,7 +26,7 @@ pub(super) fn create_tagged_union_type(
                 type_engine,
                 decl_engine,
                 context,
-                &tev.type_argument.type_id,
+                tev.type_argument.type_id,
             )
         })
         .collect::<Result<Vec<_>, CompileError>>()?;
@@ -51,7 +51,7 @@ pub(super) fn create_tuple_aggregate(
 ) -> Result<Type, CompileError> {
     let field_types = fields
         .iter()
-        .map(|ty_id| convert_resolved_typeid_no_span(type_engine, decl_engine, context, ty_id))
+        .map(|ty_id| convert_resolved_typeid_no_span(type_engine, decl_engine, context, *ty_id))
         .collect::<Result<Vec<_>, CompileError>>()?;
 
     Ok(Type::new_struct(context, field_types))
@@ -65,7 +65,7 @@ pub(super) fn create_array_aggregate(
     count: u64,
 ) -> Result<Type, CompileError> {
     let element_type =
-        convert_resolved_typeid_no_span(type_engine, decl_engine, context, &element_type_id)?;
+        convert_resolved_typeid_no_span(type_engine, decl_engine, context, element_type_id)?;
     Ok(Type::new_array(context, element_type, count))
 }
 
@@ -77,7 +77,7 @@ pub(super) fn get_struct_for_types(
 ) -> Result<Type, CompileError> {
     let types = type_ids
         .iter()
-        .map(|ty_id| convert_resolved_typeid_no_span(type_engine, decl_engine, context, ty_id))
+        .map(|ty_id| convert_resolved_typeid_no_span(type_engine, decl_engine, context, *ty_id))
         .collect::<Result<Vec<_>, CompileError>>()?;
     Ok(Type::new_struct(context, types))
 }
diff --git a/sway-core/src/language/call_path.rs b/sway-core/src/language/call_path.rs
index d0f993438b8..8036d3ecab8 100644
--- a/sway-core/src/language/call_path.rs
+++ b/sway-core/src/language/call_path.rs
@@ -215,6 +215,12 @@ impl<T: OrdWithEngines> OrdWithEngines for CallPath<T> {
     }
 }
 
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct ResolvedCallPath<T, U = Ident> {
+    pub decl: T,
+    pub unresolved_call_path: CallPath<U>,
+}
+
 impl std::convert::From<Ident> for CallPath {
     fn from(other: Ident) -> Self {
         CallPath {
@@ -336,9 +342,7 @@ impl CallPath {
     /// before the identifier is added to the environment.
     pub fn ident_to_fullpath(suffix: Ident, namespace: &Namespace) -> CallPath {
         let mut res: Self = suffix.clone().into();
-        if let Some(ref pkg_name) = namespace.root_module().name {
-            res.prefixes.push(pkg_name.clone())
-        };
+        res.prefixes.push(namespace.root_module().name().clone());
         for mod_path in namespace.mod_path() {
             res.prefixes.push(mod_path.clone())
         }
@@ -369,7 +373,7 @@ impl CallPath {
             if let Some(mod_path) = namespace.program_id(engines).read(engines, |m| {
                 if m.current_items().symbols().contains_key(&self.suffix) {
                     None
-                } else if let Some((_, path, _)) = m
+                } else if let Some((_, path, _, _)) = m
                     .current_items()
                     .use_item_synonyms
                     .get(&self.suffix)
@@ -404,9 +408,7 @@ impl CallPath {
             let mut prefixes: Vec<Ident> = vec![];
 
             if !is_external {
-                if let Some(pkg_name) = &namespace.root_module().name {
-                    prefixes.push(pkg_name.clone());
-                }
+                prefixes.push(namespace.root_module().name().clone());
 
                 if !is_absolute {
                     for mod_path in namespace.mod_path() {
@@ -439,9 +441,8 @@ impl CallPath {
                 }
             } else {
                 let mut prefixes: Vec<Ident> = vec![];
-                if let Some(pkg_name) = &namespace.root_module().read(engines, |m| m.name.clone()) {
-                    prefixes.push(pkg_name.clone());
-                }
+                prefixes.push(namespace.root_module().name().clone());
+
                 for mod_path in namespace.mod_path() {
                     prefixes.push(mod_path.clone());
                 }
@@ -473,7 +474,7 @@ impl CallPath {
         let converted = self.to_fullpath(engines, namespace);
 
         if let Some(first) = converted.prefixes.first() {
-            if namespace.root_module().read(engines, |m| m.name.clone()) == Some(first.clone()) {
+            if namespace.root_module().name() == first {
                 return converted.lshift();
             }
         }
diff --git a/sway-core/src/language/literal.rs b/sway-core/src/language/literal.rs
index a50712d04ad..afedaad12d0 100644
--- a/sway-core/src/language/literal.rs
+++ b/sway-core/src/language/literal.rs
@@ -22,6 +22,19 @@ pub enum Literal {
     B256([u8; 32]),
 }
 
+impl Literal {
+    pub fn cast_value_to_u64(&self) -> Option<u64> {
+        match self {
+            Literal::U8(v) => Some(*v as u64),
+            Literal::U16(v) => Some(*v as u64),
+            Literal::U32(v) => Some(*v as u64),
+            Literal::U64(v) => Some(*v),
+            Literal::Numeric(v) => Some(*v),
+            _ => None,
+        }
+    }
+}
+
 impl Hash for Literal {
     fn hash<H: Hasher>(&self, state: &mut H) {
         use Literal::*;
diff --git a/sway-core/src/language/parsed/declaration.rs b/sway-core/src/language/parsed/declaration.rs
index 374198cb53c..a47c4895c1b 100644
--- a/sway-core/src/language/parsed/declaration.rs
+++ b/sway-core/src/language/parsed/declaration.rs
@@ -21,6 +21,10 @@ pub use r#enum::*;
 pub use r#struct::*;
 pub use r#trait::*;
 pub use storage::*;
+use sway_error::{
+    error::CompileError,
+    handler::{ErrorEmitted, Handler},
+};
 use sway_types::{Ident, Span, Spanned};
 pub use type_alias::*;
 pub use variable::*;
@@ -29,6 +33,7 @@ use crate::{
     decl_engine::{
         parsed_engine::{ParsedDeclEngine, ParsedDeclEngineGet},
         parsed_id::ParsedDeclId,
+        DeclEngineGetParsedDeclId,
     },
     engine_threading::{
         DebugWithEngines, DisplayWithEngines, EqWithEngines, PartialEqWithEngines,
@@ -46,14 +51,14 @@ pub enum Declaration {
     StructDeclaration(ParsedDeclId<StructDeclaration>),
     EnumDeclaration(ParsedDeclId<EnumDeclaration>),
     EnumVariantDeclaration(EnumVariantDeclaration),
-    ImplTrait(ParsedDeclId<ImplTrait>),
-    ImplSelf(ParsedDeclId<ImplSelf>),
+    ImplSelfOrTrait(ParsedDeclId<ImplSelfOrTrait>),
     AbiDeclaration(ParsedDeclId<AbiDeclaration>),
     ConstantDeclaration(ParsedDeclId<ConstantDeclaration>),
     ConfigurableDeclaration(ParsedDeclId<ConfigurableDeclaration>),
     StorageDeclaration(ParsedDeclId<StorageDeclaration>),
     TypeAliasDeclaration(ParsedDeclId<TypeAliasDeclaration>),
     TraitTypeDeclaration(ParsedDeclId<TraitTypeDeclaration>),
+    TraitFnDeclaration(ParsedDeclId<TraitFn>),
 }
 
 #[derive(Debug, Clone)]
@@ -85,11 +90,11 @@ impl Declaration {
             TraitTypeDeclaration(_) => "type",
             FunctionDeclaration(_) => "function",
             TraitDeclaration(_) => "trait",
+            TraitFnDeclaration(_) => "trait fn",
             StructDeclaration(_) => "struct",
             EnumDeclaration(_) => "enum",
             EnumVariantDeclaration(_) => "enum variant",
-            ImplSelf(_) => "impl self",
-            ImplTrait(_) => "impl trait",
+            ImplSelfOrTrait(_) => "impl self/trait",
             AbiDeclaration(_) => "abi",
             StorageDeclaration(_) => "contract storage",
             TypeAliasDeclaration(_) => "type alias",
@@ -106,17 +111,62 @@ impl Declaration {
             StructDeclaration(decl_id) => pe.get_struct(decl_id).span(),
             EnumDeclaration(decl_id) => pe.get_enum(decl_id).span(),
             EnumVariantDeclaration(decl) => decl.variant_decl_span.clone(),
-            ImplTrait(decl_id) => pe.get_impl_trait(decl_id).span(),
-            ImplSelf(decl_id) => pe.get_impl_self(decl_id).span(),
+            ImplSelfOrTrait(decl_id) => pe.get_impl_self_or_trait(decl_id).span(),
             AbiDeclaration(decl_id) => pe.get_abi(decl_id).span(),
             ConstantDeclaration(decl_id) => pe.get_constant(decl_id).span(),
             ConfigurableDeclaration(decl_id) => pe.get_configurable(decl_id).span(),
             StorageDeclaration(decl_id) => pe.get_storage(decl_id).span(),
             TypeAliasDeclaration(decl_id) => pe.get_type_alias(decl_id).span(),
             TraitTypeDeclaration(decl_id) => pe.get_trait_type(decl_id).span(),
+            TraitFnDeclaration(decl_id) => pe.get_trait_fn(decl_id).span(),
+        }
+    }
+
+    pub(crate) fn to_fn_ref(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+    ) -> Result<ParsedDeclId<FunctionDeclaration>, ErrorEmitted> {
+        match self {
+            Declaration::FunctionDeclaration(decl_id) => Ok(*decl_id),
+            decl => Err(handler.emit_err(CompileError::DeclIsNotAFunction {
+                actually: decl.friendly_type_name().to_string(),
+                span: decl.span(engines),
+            })),
+        }
+    }
+
+    pub(crate) fn to_struct_decl(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+    ) -> Result<ParsedDeclId<StructDeclaration>, ErrorEmitted> {
+        match self {
+            Declaration::StructDeclaration(decl_id) => Ok(*decl_id),
+            Declaration::TypeAliasDeclaration(decl_id) => {
+                let alias = engines.pe().get_type_alias(decl_id);
+                let struct_decl_id = engines.te().get(alias.ty.type_id).expect_struct(
+                    handler,
+                    engines,
+                    &self.span(engines),
+                )?;
+
+                let parsed_decl_id = engines.de().get_parsed_decl_id(&struct_decl_id);
+                parsed_decl_id.ok_or_else(|| {
+                    handler.emit_err(CompileError::InternalOwned(
+                        "Cannot get parsed decl id from decl id".to_string(),
+                        self.span(engines),
+                    ))
+                })
+            }
+            decl => Err(handler.emit_err(CompileError::DeclIsNotAStruct {
+                actually: decl.friendly_type_name().to_string(),
+                span: decl.span(engines),
+            })),
         }
     }
 
+    #[allow(unused)]
     pub(crate) fn visibility(&self, decl_engine: &ParsedDeclEngine) -> Visibility {
         match self {
             Declaration::TraitDeclaration(decl_id) => decl_engine.get_trait(decl_id).visibility,
@@ -138,11 +188,11 @@ impl Declaration {
                 decl_engine.get_type_alias(decl_id).visibility
             }
             Declaration::VariableDeclaration(_decl_id) => Visibility::Private,
-            Declaration::ImplTrait(_)
-            | Declaration::ImplSelf(_)
+            Declaration::ImplSelfOrTrait(_)
             | Declaration::StorageDeclaration(_)
             | Declaration::AbiDeclaration(_)
-            | Declaration::TraitTypeDeclaration(_) => Visibility::Public,
+            | Declaration::TraitTypeDeclaration(_)
+            | Declaration::TraitFnDeclaration(_) => Visibility::Public,
         }
     }
 }
@@ -169,7 +219,7 @@ impl DisplayWithEngines for Declaration {
                 Declaration::EnumDeclaration(decl_id) => {
                     engines.pe().get(decl_id).name.as_str().into()
                 }
-                Declaration::ImplTrait(decl_id) => {
+                Declaration::ImplSelfOrTrait(decl_id) => {
                     engines
                         .pe()
                         .get(decl_id)
@@ -213,10 +263,7 @@ impl PartialEqWithEngines for Declaration {
             (Declaration::EnumDeclaration(lid), Declaration::EnumDeclaration(rid)) => {
                 decl_engine.get(lid).eq(&decl_engine.get(rid), ctx)
             }
-            (Declaration::ImplTrait(lid), Declaration::ImplTrait(rid)) => {
-                decl_engine.get(lid).eq(&decl_engine.get(rid), ctx)
-            }
-            (Declaration::ImplSelf(lid), Declaration::ImplSelf(rid)) => {
+            (Declaration::ImplSelfOrTrait(lid), Declaration::ImplSelfOrTrait(rid)) => {
                 decl_engine.get(lid).eq(&decl_engine.get(rid), ctx)
             }
             (Declaration::AbiDeclaration(lid), Declaration::AbiDeclaration(rid)) => {
diff --git a/sway-core/src/language/parsed/declaration/configurable.rs b/sway-core/src/language/parsed/declaration/configurable.rs
index 9a269e64680..c28eb1c2122 100644
--- a/sway-core/src/language/parsed/declaration/configurable.rs
+++ b/sway-core/src/language/parsed/declaration/configurable.rs
@@ -13,6 +13,7 @@ pub struct ConfigurableDeclaration {
     pub value: Option<Expression>,
     pub visibility: Visibility,
     pub span: Span,
+    pub block_keyword_span: Span,
 }
 
 impl Named for ConfigurableDeclaration {
diff --git a/sway-core/src/language/parsed/declaration/constant.rs b/sway-core/src/language/parsed/declaration/constant.rs
index 174c20a4121..c76a044fc15 100644
--- a/sway-core/src/language/parsed/declaration/constant.rs
+++ b/sway-core/src/language/parsed/declaration/constant.rs
@@ -14,7 +14,6 @@ pub struct ConstantDeclaration {
     pub type_ascription: TypeArgument,
     pub value: Option<Expression>,
     pub visibility: Visibility,
-    pub is_configurable: bool,
     pub span: Span,
 }
 
@@ -26,7 +25,6 @@ impl PartialEqWithEngines for ConstantDeclaration {
             && self.type_ascription.eq(&other.type_ascription, ctx)
             && self.value.eq(&other.value, ctx)
             && self.visibility == other.visibility
-            && self.is_configurable == other.is_configurable
             && self.span == other.span
     }
 }
diff --git a/sway-core/src/language/parsed/declaration/function.rs b/sway-core/src/language/parsed/declaration/function.rs
index 6232810f8f3..716f545ef0e 100644
--- a/sway-core/src/language/parsed/declaration/function.rs
+++ b/sway-core/src/language/parsed/declaration/function.rs
@@ -27,6 +27,7 @@ pub struct FunctionDeclaration {
     pub type_parameters: Vec<TypeParameter>,
     pub where_clause: Vec<(Ident, Vec<TraitConstraint>)>,
     pub kind: FunctionDeclarationKind,
+    pub implementing_type: Option<Declaration>,
 }
 
 impl EqWithEngines for FunctionDeclaration {}
diff --git a/sway-core/src/language/parsed/declaration/impl_trait.rs b/sway-core/src/language/parsed/declaration/impl_trait.rs
index c2115bd1a67..48ba779155e 100644
--- a/sway-core/src/language/parsed/declaration/impl_trait.rs
+++ b/sway-core/src/language/parsed/declaration/impl_trait.rs
@@ -1,6 +1,6 @@
 use super::{ConstantDeclaration, FunctionDeclaration, TraitTypeDeclaration};
 use crate::{
-    decl_engine::parsed_id::ParsedDeclId,
+    decl_engine::{parsed_id::ParsedDeclId, ParsedInterfaceDeclId},
     engine_threading::{
         DebugWithEngines, EqWithEngines, PartialEqWithEngines, PartialEqWithEnginesContext,
     },
@@ -61,19 +61,23 @@ impl DebugWithEngines for ImplItem {
     }
 }
 
+/// An impl trait, or impl self of methods without a trait.
+/// like `impl MyType { fn foo { .. } }`
 #[derive(Debug, Clone)]
-pub struct ImplTrait {
+pub struct ImplSelfOrTrait {
+    pub is_self: bool,
     pub impl_type_parameters: Vec<TypeParameter>,
     pub trait_name: CallPath,
     pub trait_type_arguments: Vec<TypeArgument>,
+    pub trait_decl_ref: Option<ParsedInterfaceDeclId>,
     pub implementing_for: TypeArgument,
     pub items: Vec<ImplItem>,
     // the span of the whole impl trait and block
     pub(crate) block_span: Span,
 }
 
-impl EqWithEngines for ImplTrait {}
-impl PartialEqWithEngines for ImplTrait {
+impl EqWithEngines for ImplSelfOrTrait {}
+impl PartialEqWithEngines for ImplSelfOrTrait {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         self.impl_type_parameters
             .eq(&other.impl_type_parameters, ctx)
@@ -87,61 +91,31 @@ impl PartialEqWithEngines for ImplTrait {
     }
 }
 
-impl Named for ImplTrait {
+impl Named for ImplSelfOrTrait {
     fn name(&self) -> &sway_types::BaseIdent {
         &self.trait_name.suffix
     }
 }
 
-impl Spanned for ImplTrait {
+impl Spanned for ImplSelfOrTrait {
     fn span(&self) -> sway_types::Span {
         self.block_span.clone()
     }
 }
 
-impl DebugWithEngines for ImplTrait {
+impl DebugWithEngines for ImplSelfOrTrait {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>, engines: &Engines) -> std::fmt::Result {
-        f.write_fmt(format_args!(
-            "impl {} for {:?}",
-            self.trait_name,
-            engines.help_out(self.implementing_for.clone())
-        ))
-    }
-}
-
-/// An impl of methods without a trait
-/// like `impl MyType { fn foo { .. } }`
-#[derive(Debug, Clone)]
-pub struct ImplSelf {
-    pub impl_type_parameters: Vec<TypeParameter>,
-    pub implementing_for: TypeArgument,
-    pub items: Vec<ImplItem>,
-    // the span of the whole impl trait and block
-    pub(crate) block_span: Span,
-}
-
-impl EqWithEngines for ImplSelf {}
-impl PartialEqWithEngines for ImplSelf {
-    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
-        self.impl_type_parameters
-            .eq(&other.impl_type_parameters, ctx)
-            && self.implementing_for.eq(&other.implementing_for, ctx)
-            && self.items.eq(&other.items, ctx)
-            && self.block_span == other.block_span
-    }
-}
-
-impl Spanned for ImplSelf {
-    fn span(&self) -> sway_types::Span {
-        self.block_span.clone()
-    }
-}
-
-impl DebugWithEngines for ImplSelf {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>, engines: &Engines) -> std::fmt::Result {
-        f.write_fmt(format_args!(
-            "impl {}",
-            engines.help_out(self.implementing_for.clone())
-        ))
+        if self.is_self {
+            f.write_fmt(format_args!(
+                "impl {}",
+                engines.help_out(self.implementing_for.clone())
+            ))
+        } else {
+            f.write_fmt(format_args!(
+                "impl {} for {:?}",
+                self.trait_name,
+                engines.help_out(self.implementing_for.clone())
+            ))
+        }
     }
 }
diff --git a/sway-core/src/language/parsed/declaration/trait.rs b/sway-core/src/language/parsed/declaration/trait.rs
index 35625083453..12e76e554c6 100644
--- a/sway-core/src/language/parsed/declaration/trait.rs
+++ b/sway-core/src/language/parsed/declaration/trait.rs
@@ -120,6 +120,12 @@ pub struct TraitFn {
     pub return_type: TypeArgument,
 }
 
+impl Spanned for TraitFn {
+    fn span(&self) -> sway_types::Span {
+        self.span.clone()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TraitTypeDeclaration {
     pub name: Ident,
diff --git a/sway-core/src/language/parsed/expression/asm.rs b/sway-core/src/language/parsed/expression/asm.rs
index bc5f01b20e3..98bebcab667 100644
--- a/sway-core/src/language/parsed/expression/asm.rs
+++ b/sway-core/src/language/parsed/expression/asm.rs
@@ -15,6 +15,14 @@ pub struct AsmExpression {
     pub(crate) whole_block_span: Span,
 }
 
+impl AsmExpression {
+    /// True if the [AsmExpression] has neither assembly operations nor
+    /// the return register specified.
+    pub fn is_empty(&self) -> bool {
+        self.body.is_empty() && self.returns.is_none()
+    }
+}
+
 impl EqWithEngines for AsmExpression {}
 impl PartialEqWithEngines for AsmExpression {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
diff --git a/sway-core/src/language/parsed/expression/mod.rs b/sway-core/src/language/parsed/expression/mod.rs
index 73ab3a33cbb..90d41fbf19b 100644
--- a/sway-core/src/language/parsed/expression/mod.rs
+++ b/sway-core/src/language/parsed/expression/mod.rs
@@ -1,6 +1,7 @@
 use std::{cmp::Ordering, fmt, hash::Hasher};
 
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     engine_threading::{
         DebugWithEngines, DisplayWithEngines, EqWithEngines, HashWithEngines, OrdWithEngines,
         OrdWithEnginesContext, PartialEqWithEngines, PartialEqWithEnginesContext,
@@ -22,6 +23,8 @@ pub use method_name::MethodName;
 pub use scrutinee::*;
 use sway_ast::intrinsics::Intrinsic;
 
+use super::{FunctionDeclaration, StructDeclaration};
+
 /// Represents a parsed, but not yet type checked, [Expression](https://en.wikipedia.org/wiki/Expression_(computer_science)).
 #[derive(Debug, Clone)]
 pub struct Expression {
@@ -32,6 +35,8 @@ pub struct Expression {
 #[derive(Debug, Clone)]
 pub struct FunctionApplicationExpression {
     pub call_path_binding: TypeBinding<CallPath>,
+    pub resolved_call_path_binding:
+        Option<TypeBinding<ResolvedCallPath<ParsedDeclId<FunctionDeclaration>>>>,
     pub arguments: Vec<Expression>,
 }
 
@@ -88,6 +93,8 @@ impl PartialEqWithEngines for ArrayExpression {
 
 #[derive(Debug, Clone)]
 pub struct StructExpression {
+    pub resolved_call_path_binding:
+        Option<TypeBinding<ResolvedCallPath<ParsedDeclId<StructDeclaration>>>>,
     pub call_path_binding: TypeBinding<CallPath>,
     pub fields: Vec<StructExpressionField>,
 }
diff --git a/sway-core/src/language/parsed/use_statement.rs b/sway-core/src/language/parsed/use_statement.rs
index 9734d4f8bfc..ceda688d75f 100644
--- a/sway-core/src/language/parsed/use_statement.rs
+++ b/sway-core/src/language/parsed/use_statement.rs
@@ -1,4 +1,4 @@
-use crate::parsed::Span;
+use crate::{language::Visibility, parsed::Span};
 use sway_types::ident::Ident;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -17,5 +17,8 @@ pub struct UseStatement {
     // If `is_absolute` is true, then this use statement is an absolute path from
     // the project root namespace. If not, then it is relative to the current namespace.
     pub is_absolute: bool,
+    // If `reexport` is Visibility::Public, then this use statement reexports its imported binding.
+    // If not, then the import binding is private to the importing module.
+    pub reexport: Visibility,
     pub alias: Option<Ident>,
 }
diff --git a/sway-core/src/language/ty/ast_node.rs b/sway-core/src/language/ty/ast_node.rs
index 35020a34c99..59d9e942004 100644
--- a/sway-core/src/language/ty/ast_node.rs
+++ b/sway-core/src/language/ty/ast_node.rs
@@ -61,10 +61,10 @@ impl DebugWithEngines for TyAstNode {
 }
 
 impl SubstTypes for TyAstNode {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         match self.content {
-            TyAstNodeContent::Declaration(ref mut decl) => decl.subst(type_mapping, engines),
-            TyAstNodeContent::Expression(ref mut expr) => expr.subst(type_mapping, engines),
+            TyAstNodeContent::Declaration(ref mut decl) => decl.subst(ctx),
+            TyAstNodeContent::Expression(ref mut expr) => expr.subst(ctx),
             TyAstNodeContent::SideEffect(_) | TyAstNodeContent::Error(_, _) => HasChanges::No,
         }
     }
@@ -236,7 +236,7 @@ impl TyAstNode {
                     }
                     allow_deprecated.exit(token);
                 }
-                TyDecl::ImplTrait(decl) => {
+                TyDecl::ImplSelfOrTrait(decl) => {
                     let decl = engines.de().get(&decl.decl_id);
                     for item in decl.items.iter() {
                         match item {
@@ -293,7 +293,7 @@ impl TyAstNode {
                         let _ = fn_decl_id.type_check_analyze(handler, &mut ctx);
                         let _ = ctx.check_recursive_calls(handler);
                     }
-                    TyDecl::ImplTrait(decl) => {
+                    TyDecl::ImplSelfOrTrait(decl) => {
                         let decl = engines.de().get(&decl.decl_id);
                         for item in decl.items.iter() {
                             let mut ctx = TypeCheckAnalysisContext::new(engines);
@@ -318,15 +318,32 @@ impl TyAstNode {
         })
     }
 
-    pub fn contract_fns(&self, engines: &Engines) -> Vec<DeclRefFunction> {
+    pub fn contract_supertrait_fns(&self, engines: &Engines) -> Vec<DeclId<TyFunctionDecl>> {
         let mut fns = vec![];
 
-        if let TyAstNodeContent::Declaration(TyDecl::ImplTrait(decl)) = &self.content {
+        if let TyAstNodeContent::Declaration(TyDecl::ImplSelfOrTrait(decl)) = &self.content {
+            let decl = engines.de().get(&decl.decl_id);
+            if decl.is_impl_contract(engines.te()) {
+                for item in &decl.supertrait_items {
+                    if let TyTraitItem::Fn(f) = item {
+                        fns.push(*f.id());
+                    }
+                }
+            }
+        }
+
+        fns
+    }
+
+    pub fn contract_fns(&self, engines: &Engines) -> Vec<DeclId<TyFunctionDecl>> {
+        let mut fns = vec![];
+
+        if let TyAstNodeContent::Declaration(TyDecl::ImplSelfOrTrait(decl)) = &self.content {
             let decl = engines.de().get(&decl.decl_id);
             if decl.is_impl_contract(engines.te()) {
                 for item in &decl.items {
                     if let TyTraitItem::Fn(f) = item {
-                        fns.push(f.clone());
+                        fns.push(*f.id());
                     }
                 }
             }
diff --git a/sway-core/src/language/ty/code_block.rs b/sway-core/src/language/ty/code_block.rs
index e0642c9324a..6ae9b0d0dea 100644
--- a/sway-core/src/language/ty/code_block.rs
+++ b/sway-core/src/language/ty/code_block.rs
@@ -38,8 +38,8 @@ impl HashWithEngines for TyCodeBlock {
 }
 
 impl SubstTypes for TyCodeBlock {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.contents.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.contents.subst(ctx)
     }
 }
 
diff --git a/sway-core/src/language/ty/declaration/abi.rs b/sway-core/src/language/ty/declaration/abi.rs
index c147b9d270e..5ad5ea2c3dc 100644
--- a/sway-core/src/language/ty/declaration/abi.rs
+++ b/sway-core/src/language/ty/declaration/abi.rs
@@ -1,9 +1,14 @@
-use crate::{engine_threading::*, language::parsed, transform, type_system::*};
+use crate::{
+    engine_threading::*,
+    language::parsed::{self, AbiDeclaration},
+    transform,
+    type_system::*,
+};
 use std::hash::{Hash, Hasher};
 
 use sway_types::{Ident, Named, Span, Spanned};
 
-use super::{TyTraitInterfaceItem, TyTraitItem};
+use super::{TyDeclParsedType, TyTraitInterfaceItem, TyTraitItem};
 
 /// A [TyAbiDecl] contains the type-checked version of the parse tree's
 /// `AbiDeclaration`.
@@ -19,6 +24,10 @@ pub struct TyAbiDecl {
     pub attributes: transform::AttributesMap,
 }
 
+impl TyDeclParsedType for TyAbiDecl {
+    type ParsedType = AbiDeclaration;
+}
+
 impl EqWithEngines for TyAbiDecl {}
 impl PartialEqWithEngines for TyAbiDecl {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
diff --git a/sway-core/src/language/ty/declaration/configurable.rs b/sway-core/src/language/ty/declaration/configurable.rs
index 3c3adf15216..da7349fc91b 100644
--- a/sway-core/src/language/ty/declaration/configurable.rs
+++ b/sway-core/src/language/ty/declaration/configurable.rs
@@ -10,7 +10,7 @@ use crate::{
     decl_engine::{DeclId, DeclMapping, DeclRef, ReplaceDecls},
     engine_threading::*,
     has_changes,
-    language::{ty::*, CallPath, Visibility},
+    language::{parsed::ConfigurableDeclaration, ty::*, CallPath, Visibility},
     semantic_analysis::TypeCheckContext,
     transform,
     type_system::*,
@@ -29,6 +29,10 @@ pub struct TyConfigurableDecl {
     pub decode_fn: Option<DeclRef<DeclId<TyFunctionDecl>>>,
 }
 
+impl TyDeclParsedType for TyConfigurableDecl {
+    type ParsedType = ConfigurableDeclaration;
+}
+
 impl DebugWithEngines for TyConfigurableDecl {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, _engines: &Engines) -> fmt::Result {
         write!(f, "{}", self.call_path)
@@ -85,11 +89,11 @@ impl Spanned for TyConfigurableDecl {
 }
 
 impl SubstTypes for TyConfigurableDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.return_type.subst(type_mapping, engines);
-            self.type_ascription.subst(type_mapping, engines);
-            self.value.subst(type_mapping, engines);
+            self.return_type.subst(ctx);
+            self.type_ascription.subst(ctx);
+            self.value.subst(ctx);
         }
     }
 }
diff --git a/sway-core/src/language/ty/declaration/constant.rs b/sway-core/src/language/ty/declaration/constant.rs
index 89fd42ce83b..c8acda6b5cf 100644
--- a/sway-core/src/language/ty/declaration/constant.rs
+++ b/sway-core/src/language/ty/declaration/constant.rs
@@ -10,7 +10,7 @@ use crate::{
     decl_engine::{DeclMapping, ReplaceDecls},
     engine_threading::*,
     has_changes,
-    language::{ty::*, CallPath, Visibility},
+    language::{parsed::ConstantDeclaration, ty::*, CallPath, Visibility},
     semantic_analysis::TypeCheckContext,
     transform,
     type_system::*,
@@ -27,6 +27,10 @@ pub struct TyConstantDecl {
     pub span: Span,
 }
 
+impl TyDeclParsedType for TyConstantDecl {
+    type ParsedType = ConstantDeclaration;
+}
+
 impl DebugWithEngines for TyConstantDecl {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, _engines: &Engines) -> fmt::Result {
         write!(f, "{}", self.call_path)
@@ -81,12 +85,19 @@ impl Spanned for TyConstantDecl {
     }
 }
 
+impl IsConcrete for TyConstantDecl {
+    fn is_concrete(&self, engines: &Engines) -> bool {
+        self.return_type
+            .is_concrete(engines, TreatNumericAs::Concrete)
+    }
+}
+
 impl SubstTypes for TyConstantDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.return_type.subst(type_mapping, engines);
-            self.type_ascription.subst(type_mapping, engines);
-            self.value.subst(type_mapping, engines);
+            self.return_type.subst(ctx);
+            self.type_ascription.subst(ctx);
+            self.value.subst(ctx);
         }
     }
 }
diff --git a/sway-core/src/language/ty/declaration/declaration.rs b/sway-core/src/language/ty/declaration/declaration.rs
index a1fd8d42893..9bd68ec0046 100644
--- a/sway-core/src/language/ty/declaration/declaration.rs
+++ b/sway-core/src/language/ty/declaration/declaration.rs
@@ -12,7 +12,7 @@ use sway_types::{Ident, Named, Span, Spanned};
 use crate::{
     decl_engine::*,
     engine_threading::*,
-    language::{ty::*, Visibility},
+    language::{parsed::Declaration, ty::*, Visibility},
     type_system::*,
     types::*,
 };
@@ -28,7 +28,7 @@ pub enum TyDecl {
     StructDecl(StructDecl),
     EnumDecl(EnumDecl),
     EnumVariantDecl(EnumVariantDecl),
-    ImplTrait(ImplTrait),
+    ImplSelfOrTrait(ImplSelfOrTrait),
     AbiDecl(AbiDecl),
     // If type parameters are defined for a function, they are put in the namespace just for
     // the body of that function.
@@ -38,6 +38,14 @@ pub enum TyDecl {
     TypeAliasDecl(TypeAliasDecl),
 }
 
+/// This trait is used to associate a typed declaration node with its
+/// corresponding parsed declaration node by way of an associated type.
+/// This is used by the generic code in [`DeclEngine`] related to handling
+/// typed to parsed node maps.
+pub trait TyDeclParsedType {
+    type ParsedType;
+}
+
 #[derive(Clone, Debug)]
 pub struct ConstantDecl {
     pub decl_id: DeclId<TyConstantDecl>,
@@ -81,8 +89,8 @@ pub struct EnumVariantDecl {
 }
 
 #[derive(Clone, Debug)]
-pub struct ImplTrait {
-    pub decl_id: DeclId<TyImplTrait>,
+pub struct ImplSelfOrTrait {
+    pub decl_id: DeclId<TyImplSelfOrTrait>,
 }
 
 #[derive(Clone, Debug)]
@@ -151,8 +159,8 @@ impl PartialEqWithEngines for TyDecl {
                         .eq(&decl_engine.get_enum(r_enum), ctx)
             }
             (
-                TyDecl::ImplTrait(ImplTrait { decl_id: lid, .. }),
-                TyDecl::ImplTrait(ImplTrait { decl_id: rid, .. }),
+                TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id: lid, .. }),
+                TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id: rid, .. }),
             ) => decl_engine.get(lid).eq(&decl_engine.get(rid), ctx),
             (
                 TyDecl::AbiDecl(AbiDecl { decl_id: lid, .. }),
@@ -220,7 +228,7 @@ impl HashWithEngines for TyDecl {
                 enum_ref.hash(state, engines);
                 variant_name.hash(state);
             }
-            TyDecl::ImplTrait(ImplTrait { decl_id, .. }) => {
+            TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id, .. }) => {
                 decl_engine.get(decl_id).hash(state, engines);
             }
             TyDecl::AbiDecl(AbiDecl { decl_id, .. }) => {
@@ -242,33 +250,33 @@ impl HashWithEngines for TyDecl {
 }
 
 impl SubstTypes for TyDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         match self {
-            TyDecl::VariableDecl(ref mut var_decl) => var_decl.subst(type_mapping, engines),
+            TyDecl::VariableDecl(ref mut var_decl) => var_decl.subst(ctx),
             TyDecl::FunctionDecl(FunctionDecl {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             TyDecl::TraitDecl(TraitDecl {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             TyDecl::StructDecl(StructDecl {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             TyDecl::EnumDecl(EnumDecl {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             TyDecl::EnumVariantDecl(EnumVariantDecl {
                 ref mut enum_ref, ..
-            }) => enum_ref.subst(type_mapping, engines),
-            TyDecl::ImplTrait(ImplTrait {
+            }) => enum_ref.subst(ctx),
+            TyDecl::ImplSelfOrTrait(ImplSelfOrTrait {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             TyDecl::TypeAliasDecl(TypeAliasDecl {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             TyDecl::TraitTypeDecl(TraitTypeDecl {
                 ref mut decl_id, ..
-            }) => decl_id.subst(type_mapping, engines),
+            }) => decl_id.subst(ctx),
             // generics in an ABI is unsupported by design
             TyDecl::AbiDecl(_)
             | TyDecl::ConstantDecl(_)
@@ -304,8 +312,8 @@ impl SpannedWithEngines for TyDecl {
                 engines.de().get_struct(decl_id).span.clone()
             }
             TyDecl::EnumDecl(EnumDecl { decl_id }) => engines.de().get_enum(decl_id).span.clone(),
-            TyDecl::ImplTrait(ImplTrait { decl_id }) => {
-                engines.de().get_impl_trait(decl_id).span.clone()
+            TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id }) => {
+                engines.de().get_impl_self_or_trait(decl_id).span.clone()
             }
             TyDecl::AbiDecl(AbiDecl { decl_id }) => engines.de().get_abi(decl_id).span.clone(),
             TyDecl::VariableDecl(decl) => decl.name.span(),
@@ -369,7 +377,7 @@ impl DisplayWithEngines for TyDecl {
                 TyDecl::EnumDecl(EnumDecl { decl_id }) => {
                     engines.de().get(decl_id).name().as_str().into()
                 }
-                TyDecl::ImplTrait(ImplTrait { decl_id }) => {
+                TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id }) => {
                     engines.de().get(decl_id).name().as_str().into()
                 }
                 TyDecl::TypeAliasDecl(TypeAliasDecl { decl_id }) =>
@@ -433,7 +441,7 @@ impl CollectTypesMetadata for TyDecl {
             | TyDecl::StructDecl(_)
             | TyDecl::EnumDecl(_)
             | TyDecl::EnumVariantDecl(_)
-            | TyDecl::ImplTrait(_)
+            | TyDecl::ImplSelfOrTrait(_)
             | TyDecl::AbiDecl(_)
             | TyDecl::TypeAliasDecl(_)
             | TyDecl::TraitTypeDecl(_)
@@ -467,7 +475,7 @@ impl GetDeclIdent for TyDecl {
             TyDecl::EnumDecl(EnumDecl { decl_id }) => {
                 Some(engines.de().get(decl_id).name().clone())
             }
-            TyDecl::ImplTrait(ImplTrait { decl_id }) => {
+            TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id }) => {
                 Some(engines.de().get(decl_id).name().clone())
             }
             TyDecl::AbiDecl(AbiDecl { decl_id }) => Some(engines.de().get(decl_id).name().clone()),
@@ -488,23 +496,36 @@ impl GetDeclIdent for TyDecl {
 }
 
 impl TyDecl {
-    /// Retrieves the declaration as a `DeclRef<DeclId<TyEnumDecl>>`.
+    pub(crate) fn get_parsed_decl(&self, decl_engine: &DeclEngine) -> Option<Declaration> {
+        match self {
+            TyDecl::VariableDecl(_decl) => None,
+            TyDecl::ConstantDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::ConfigurableDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::TraitTypeDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::FunctionDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::TraitDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::StructDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::EnumDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::EnumVariantDecl(decl) => decl_engine.get_parsed_decl(decl.enum_ref.id()),
+            TyDecl::ImplSelfOrTrait(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::AbiDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::GenericTypeForFunctionScope(_data) => None,
+            TyDecl::ErrorRecovery(_, _) => None,
+            TyDecl::StorageDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+            TyDecl::TypeAliasDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
+        }
+    }
+
+    /// Retrieves the declaration as a `DeclId<TyEnumDecl>`.
     ///
     /// Returns an error if `self` is not the [TyDecl][EnumDecl] variant.
-    pub(crate) fn to_enum_ref(
+    pub(crate) fn to_enum_id(
         &self,
         handler: &Handler,
         engines: &Engines,
-    ) -> Result<DeclRefEnum, ErrorEmitted> {
+    ) -> Result<DeclId<TyEnumDecl>, ErrorEmitted> {
         match self {
-            TyDecl::EnumDecl(EnumDecl { decl_id }) => {
-                let enum_decl = engines.de().get_enum(decl_id);
-                Ok(DeclRef::new(
-                    enum_decl.name().clone(),
-                    *decl_id,
-                    enum_decl.span.clone(),
-                ))
-            }
+            TyDecl::EnumDecl(EnumDecl { decl_id }) => Ok(*decl_id),
             TyDecl::TypeAliasDecl(TypeAliasDecl { decl_id, .. }) => {
                 let alias_decl = engines.de().get_type_alias(decl_id);
                 let TyTypeAliasDecl { ty, span, .. } = &*alias_decl;
@@ -517,7 +538,7 @@ impl TyDecl {
             TyDecl::GenericTypeForFunctionScope(GenericTypeForFunctionScope {
                 type_id, ..
             }) => match &*engines.te().get(*type_id) {
-                TypeInfo::Enum(r) => Ok(r.clone()),
+                TypeInfo::Enum(r) => Ok(*r),
                 _ => Err(handler.emit_err(CompileError::DeclIsNotAnEnum {
                     actually: self.friendly_type_name().to_string(),
                     span: self.span(engines),
@@ -534,20 +555,13 @@ impl TyDecl {
     /// Retrieves the declaration as a `DeclRef<DeclId<TyStructDecl>>`.
     ///
     /// Returns an error if `self` is not the [TyDecl][StructDecl] variant.
-    pub(crate) fn to_struct_ref(
+    pub(crate) fn to_struct_decl(
         &self,
         handler: &Handler,
         engines: &Engines,
-    ) -> Result<DeclRefStruct, ErrorEmitted> {
+    ) -> Result<DeclId<TyStructDecl>, ErrorEmitted> {
         match self {
-            TyDecl::StructDecl(StructDecl { decl_id }) => {
-                let struct_decl = engines.de().get_struct(decl_id);
-                Ok(DeclRef::new(
-                    struct_decl.name().clone(),
-                    *decl_id,
-                    struct_decl.span.clone(),
-                ))
-            }
+            TyDecl::StructDecl(StructDecl { decl_id }) => Ok(*decl_id),
             TyDecl::TypeAliasDecl(TypeAliasDecl { decl_id, .. }) => {
                 let alias_decl = engines.de().get_type_alias(decl_id);
                 let TyTypeAliasDecl { ty, span, .. } = &*alias_decl;
@@ -659,8 +673,8 @@ impl TyDecl {
         let decl_engine = engines.de();
         let type_engine = engines.te();
         match self {
-            TyDecl::ImplTrait(ImplTrait { decl_id, .. }) => {
-                let decl = decl_engine.get_impl_trait(decl_id);
+            TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id, .. }) => {
+                let decl = decl_engine.get_impl_self_or_trait(decl_id);
                 let implementing_for_type_id_arc = type_engine.get(decl.implementing_for.type_id);
                 let implementing_for_type_id = &*implementing_for_type_id_arc;
                 format!(
@@ -696,7 +710,7 @@ impl TyDecl {
             StructDecl(_) => "struct",
             EnumDecl(_) => "enum",
             EnumVariantDecl(_) => "enum variant",
-            ImplTrait(_) => "impl trait",
+            ImplSelfOrTrait(_) => "impl trait",
             AbiDecl(_) => "abi",
             GenericTypeForFunctionScope(_) => "generic type parameter",
             ErrorRecovery(_, _) => "error",
@@ -729,11 +743,7 @@ impl TyDecl {
                 let decl = decl_engine.get_struct(decl_id);
                 type_engine.insert(
                     engines,
-                    TypeInfo::Struct(DeclRef::new(
-                        decl.name().clone(),
-                        *decl_id,
-                        decl.span.clone(),
-                    )),
+                    TypeInfo::Struct(*decl_id),
                     decl.name().span().source_id(),
                 )
             }
@@ -741,11 +751,7 @@ impl TyDecl {
                 let decl = decl_engine.get_enum(decl_id);
                 type_engine.insert(
                     engines,
-                    TypeInfo::Enum(DeclRef::new(
-                        decl.name().clone(),
-                        *decl_id,
-                        decl.span.clone(),
-                    )),
+                    TypeInfo::Enum(*decl_id),
                     decl.name().span().source_id(),
                 )
             }
@@ -802,7 +808,7 @@ impl TyDecl {
                 decl_engine.get_type_alias(decl_id).visibility
             }
             TyDecl::GenericTypeForFunctionScope(_)
-            | TyDecl::ImplTrait(_)
+            | TyDecl::ImplSelfOrTrait(_)
             | TyDecl::StorageDecl(_)
             | TyDecl::AbiDecl(_)
             | TyDecl::TraitTypeDecl(_)
@@ -860,9 +866,9 @@ impl From<DeclRef<DeclId<TyTraitDecl>>> for TyDecl {
     }
 }
 
-impl From<DeclRef<DeclId<TyImplTrait>>> for TyDecl {
-    fn from(decl_ref: DeclRef<DeclId<TyImplTrait>>) -> Self {
-        TyDecl::ImplTrait(ImplTrait {
+impl From<DeclRef<DeclId<TyImplSelfOrTrait>>> for TyDecl {
+    fn from(decl_ref: DeclRef<DeclId<TyImplSelfOrTrait>>) -> Self {
+        TyDecl::ImplSelfOrTrait(ImplSelfOrTrait {
             decl_id: *decl_ref.id(),
         })
     }
diff --git a/sway-core/src/language/ty/declaration/enum.rs b/sway-core/src/language/ty/declaration/enum.rs
index 36af57315cf..2ce5e3eae46 100644
--- a/sway-core/src/language/ty/declaration/enum.rs
+++ b/sway-core/src/language/ty/declaration/enum.rs
@@ -3,6 +3,7 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+use monomorphization::MonomorphizeHelper;
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
@@ -12,12 +13,13 @@ use sway_types::{Ident, Named, Span, Spanned};
 use crate::{
     engine_threading::*,
     has_changes,
-    language::{CallPath, Visibility},
-    semantic_analysis::type_check_context::MonomorphizeHelper,
+    language::{parsed::EnumDeclaration, CallPath, Visibility},
     transform,
     type_system::*,
 };
 
+use super::TyDeclParsedType;
+
 #[derive(Clone, Debug)]
 pub struct TyEnumDecl {
     pub call_path: CallPath,
@@ -28,6 +30,10 @@ pub struct TyEnumDecl {
     pub visibility: Visibility,
 }
 
+impl TyDeclParsedType for TyEnumDecl {
+    type ParsedType = EnumDeclaration;
+}
+
 impl Named for TyEnumDecl {
     fn name(&self) -> &Ident {
         &self.call_path.suffix
@@ -64,10 +70,10 @@ impl HashWithEngines for TyEnumDecl {
 }
 
 impl SubstTypes for TyEnumDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.variants.subst(type_mapping, engines);
-            self.type_parameters.subst(type_mapping, engines);
+            self.variants.subst(ctx);
+            self.type_parameters.subst(ctx);
         }
     }
 }
@@ -78,6 +84,14 @@ impl Spanned for TyEnumDecl {
     }
 }
 
+impl IsConcrete for TyEnumDecl {
+    fn is_concrete(&self, engines: &Engines) -> bool {
+        self.type_parameters
+            .iter()
+            .all(|tp| tp.is_concrete(engines))
+    }
+}
+
 impl MonomorphizeHelper for TyEnumDecl {
     fn type_parameters(&self) -> &[TypeParameter] {
         &self.type_parameters
@@ -172,7 +186,7 @@ impl OrdWithEngines for TyEnumVariant {
 }
 
 impl SubstTypes for TyEnumVariant {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.type_argument.subst_inner(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.type_argument.subst_inner(ctx)
     }
 }
diff --git a/sway-core/src/language/ty/declaration/function.rs b/sway-core/src/language/ty/declaration/function.rs
index cf18cf0305e..8bb26f1f598 100644
--- a/sway-core/src/language/ty/declaration/function.rs
+++ b/sway-core/src/language/ty/declaration/function.rs
@@ -1,16 +1,18 @@
 use std::{
-    collections::HashSet,
     fmt,
     hash::{Hash, Hasher},
 };
 
+use monomorphization::MonomorphizeHelper;
 use sha2::{Digest, Sha256};
 use sway_error::handler::{ErrorEmitted, Handler};
 
 use crate::{
     has_changes,
-    language::{parsed::FunctionDeclarationKind, CallPath},
-    semantic_analysis::type_check_context::MonomorphizeHelper,
+    language::{
+        parsed::{FunctionDeclaration, FunctionDeclarationKind},
+        CallPath,
+    },
     transform::AttributeKind,
 };
 
@@ -59,6 +61,10 @@ pub struct TyFunctionDecl {
     pub kind: TyFunctionDeclKind,
 }
 
+impl TyDeclParsedType for TyFunctionDecl {
+    type ParsedType = FunctionDeclaration;
+}
+
 impl DebugWithEngines for TyFunctionDecl {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
         write!(
@@ -139,6 +145,22 @@ impl Named for TyFunctionDecl {
     }
 }
 
+impl IsConcrete for TyFunctionDecl {
+    fn is_concrete(&self, engines: &Engines) -> bool {
+        self.type_parameters
+            .iter()
+            .all(|tp| tp.is_concrete(engines))
+            && self
+                .return_type
+                .type_id
+                .is_concrete(engines, TreatNumericAs::Concrete)
+            && self.parameters().iter().all(|t| {
+                t.type_argument
+                    .type_id
+                    .is_concrete(engines, TreatNumericAs::Concrete)
+            })
+    }
+}
 impl declaration::FunctionSignature for TyFunctionDecl {
     fn parameters(&self) -> &Vec<TyFunctionParameter> {
         &self.parameters
@@ -198,13 +220,22 @@ impl HashWithEngines for TyFunctionDecl {
 }
 
 impl SubstTypes for TyFunctionDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        has_changes! {
-            self.type_parameters.subst(type_mapping, engines);
-            self.parameters.subst(type_mapping, engines);
-            self.return_type.subst(type_mapping, engines);
-            self.body.subst(type_mapping, engines);
-            self.implementing_for_typeid.subst(type_mapping, engines);
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        if ctx.subst_function_body {
+            has_changes! {
+                self.type_parameters.subst(ctx);
+                self.parameters.subst(ctx);
+                self.return_type.subst(ctx);
+                self.body.subst(ctx);
+                self.implementing_for_typeid.subst(ctx);
+            }
+        } else {
+            has_changes! {
+                self.type_parameters.subst(ctx);
+                self.parameters.subst(ctx);
+                self.return_type.subst(ctx);
+                self.implementing_for_typeid.subst(ctx);
+            }
         }
     }
 }
@@ -242,42 +273,6 @@ impl MonomorphizeHelper for TyFunctionDecl {
     }
 }
 
-impl UnconstrainedTypeParameters for TyFunctionDecl {
-    fn type_parameter_is_unconstrained(
-        &self,
-        engines: &Engines,
-        type_parameter: &TypeParameter,
-    ) -> bool {
-        let type_engine = engines.te();
-        let mut all_types: HashSet<TypeId> = self
-            .type_parameters
-            .iter()
-            .map(|type_param| type_param.type_id)
-            .collect();
-        all_types.extend(self.parameters.iter().flat_map(|param| {
-            let mut inner = param
-                .type_argument
-                .type_id
-                .extract_inner_types(engines, IncludeSelf::No);
-            inner.insert(param.type_argument.type_id);
-            inner
-        }));
-        all_types.extend(
-            self.return_type
-                .type_id
-                .extract_inner_types(engines, IncludeSelf::No),
-        );
-        all_types.insert(self.return_type.type_id);
-        let type_parameter_info = type_engine.get(type_parameter.type_id);
-        all_types.iter().any(|type_id| {
-            type_engine.get(*type_id).eq(
-                &type_parameter_info,
-                &PartialEqWithEnginesContext::new(engines),
-            )
-        })
-    }
-}
-
 impl CollectTypesMetadata for TyFunctionDecl {
     fn collect_types_metadata(
         &self,
@@ -471,7 +466,7 @@ impl TyFunctionDecl {
         };
 
         match &self.implementing_type {
-            Some(TyDecl::ImplTrait(t)) => {
+            Some(TyDecl::ImplSelfOrTrait(t)) => {
                 let unify_check = UnifyCheck::non_dynamic_equality(engines);
 
                 let implementing_for = engines.de().get(&t.decl_id).implementing_for.type_id;
@@ -532,8 +527,8 @@ impl HashWithEngines for TyFunctionParameter {
 }
 
 impl SubstTypes for TyFunctionParameter {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.type_argument.type_id.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.type_argument.type_id.subst(ctx)
     }
 }
 
@@ -602,9 +597,16 @@ impl TyFunctionSig {
     }
 
     pub fn is_concrete(&self, engines: &Engines) -> bool {
-        self.return_type.is_concrete(engines)
-            && self.parameters.iter().all(|p| p.is_concrete(engines))
-            && self.type_parameters.iter().all(|p| p.is_concrete(engines))
+        self.return_type
+            .is_concrete(engines, TreatNumericAs::Concrete)
+            && self
+                .parameters
+                .iter()
+                .all(|p| p.is_concrete(engines, TreatNumericAs::Concrete))
+            && self
+                .type_parameters
+                .iter()
+                .all(|p| p.is_concrete(engines, TreatNumericAs::Concrete))
     }
 
     /// Returns a String representing the function.
diff --git a/sway-core/src/language/ty/declaration/impl_trait.rs b/sway-core/src/language/ty/declaration/impl_trait.rs
index 151be5fae58..0c2d25aa5fd 100644
--- a/sway-core/src/language/ty/declaration/impl_trait.rs
+++ b/sway-core/src/language/ty/declaration/impl_trait.rs
@@ -3,46 +3,54 @@ use std::hash::{Hash, Hasher};
 use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
-    decl_engine::DeclRefMixedInterface, engine_threading::*, has_changes, language::CallPath,
+    decl_engine::DeclRefMixedInterface,
+    engine_threading::*,
+    has_changes,
+    language::{parsed::ImplSelfOrTrait, CallPath},
     type_system::*,
 };
 
-use super::TyTraitItem;
+use super::{TyDeclParsedType, TyTraitItem};
 
 pub type TyImplItem = TyTraitItem;
 
 // impl <A, B, C> Trait<Arg, Arg> for Type<Arg, Arg>
 #[derive(Clone, Debug)]
-pub struct TyImplTrait {
+pub struct TyImplSelfOrTrait {
     pub impl_type_parameters: Vec<TypeParameter>,
     pub trait_name: CallPath,
     pub trait_type_arguments: Vec<TypeArgument>,
     pub items: Vec<TyImplItem>,
+    pub supertrait_items: Vec<TyImplItem>,
     pub trait_decl_ref: Option<DeclRefMixedInterface>,
     pub implementing_for: TypeArgument,
     pub span: Span,
 }
 
-impl TyImplTrait {
+impl TyImplSelfOrTrait {
     pub fn is_impl_contract(&self, te: &TypeEngine) -> bool {
         matches!(&*te.get(self.implementing_for.type_id), TypeInfo::Contract)
     }
 }
 
-impl Named for TyImplTrait {
+impl TyDeclParsedType for TyImplSelfOrTrait {
+    type ParsedType = ImplSelfOrTrait;
+}
+
+impl Named for TyImplSelfOrTrait {
     fn name(&self) -> &Ident {
         &self.trait_name.suffix
     }
 }
 
-impl Spanned for TyImplTrait {
+impl Spanned for TyImplSelfOrTrait {
     fn span(&self) -> Span {
         self.span.clone()
     }
 }
 
-impl EqWithEngines for TyImplTrait {}
-impl PartialEqWithEngines for TyImplTrait {
+impl EqWithEngines for TyImplSelfOrTrait {}
+impl PartialEqWithEngines for TyImplSelfOrTrait {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
         self.impl_type_parameters
             .eq(&other.impl_type_parameters, ctx)
@@ -56,9 +64,9 @@ impl PartialEqWithEngines for TyImplTrait {
     }
 }
 
-impl HashWithEngines for TyImplTrait {
+impl HashWithEngines for TyImplSelfOrTrait {
     fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
-        let TyImplTrait {
+        let TyImplSelfOrTrait {
             impl_type_parameters,
             trait_name,
             trait_type_arguments,
@@ -68,6 +76,7 @@ impl HashWithEngines for TyImplTrait {
             // these fields are not hashed because they aren't relevant/a
             // reliable source of obj v. obj distinction
             span: _,
+            supertrait_items: _,
         } = self;
         trait_name.hash(state);
         impl_type_parameters.hash(state, engines);
@@ -78,12 +87,12 @@ impl HashWithEngines for TyImplTrait {
     }
 }
 
-impl SubstTypes for TyImplTrait {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+impl SubstTypes for TyImplSelfOrTrait {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.impl_type_parameters.subst(type_mapping, engines);
-            self.implementing_for.subst_inner(type_mapping, engines);
-            self.items.subst(type_mapping, engines);
+            self.impl_type_parameters.subst(ctx);
+            self.implementing_for.subst_inner(ctx);
+            self.items.subst(ctx);
         }
     }
 }
diff --git a/sway-core/src/language/ty/declaration/storage.rs b/sway-core/src/language/ty/declaration/storage.rs
index cb1e9c6b648..767d5728ee7 100644
--- a/sway-core/src/language/ty/declaration/storage.rs
+++ b/sway-core/src/language/ty/declaration/storage.rs
@@ -8,7 +8,7 @@ use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
     engine_threading::*,
-    language::{ty::*, Visibility},
+    language::{parsed::StorageDeclaration, ty::*, Visibility},
     transform::{self},
     type_system::*,
     Namespace,
@@ -22,6 +22,10 @@ pub struct TyStorageDecl {
     pub storage_keyword: Ident,
 }
 
+impl TyDeclParsedType for TyStorageDecl {
+    type ParsedType = StorageDeclaration;
+}
+
 impl Named for TyStorageDecl {
     fn name(&self) -> &Ident {
         &self.storage_keyword
@@ -108,7 +112,10 @@ impl TyStorageDecl {
                 None => {
                     return Err(handler.emit_err(CompileError::StorageFieldDoesNotExist {
                         field_name: first_field.into(),
-                        available_fields: storage_fields.iter().map(|sf| sf.name.clone()).collect(),
+                        available_fields: storage_fields
+                            .iter()
+                            .map(|sf| (sf.namespace_names.clone(), sf.name.clone()))
+                            .collect(),
                         storage_decl_span: self.span(),
                     }));
                 }
diff --git a/sway-core/src/language/ty/declaration/struct.rs b/sway-core/src/language/ty/declaration/struct.rs
index 3ebd5c71771..c4dc7e3e219 100644
--- a/sway-core/src/language/ty/declaration/struct.rs
+++ b/sway-core/src/language/ty/declaration/struct.rs
@@ -3,19 +3,21 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+use monomorphization::MonomorphizeHelper;
 use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
     engine_threading::*,
     error::module_can_be_changed,
     has_changes,
-    language::{CallPath, Visibility},
-    semantic_analysis::type_check_context::MonomorphizeHelper,
+    language::{parsed::StructDeclaration, CallPath, Visibility},
     transform,
     type_system::*,
     Namespace,
 };
 
+use super::TyDeclParsedType;
+
 #[derive(Clone, Debug)]
 pub struct TyStructDecl {
     pub call_path: CallPath,
@@ -26,6 +28,10 @@ pub struct TyStructDecl {
     pub attributes: transform::AttributesMap,
 }
 
+impl TyDeclParsedType for TyStructDecl {
+    type ParsedType = StructDeclaration;
+}
+
 impl Named for TyStructDecl {
     fn name(&self) -> &Ident {
         &self.call_path.suffix
@@ -62,10 +68,10 @@ impl HashWithEngines for TyStructDecl {
 }
 
 impl SubstTypes for TyStructDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.fields.subst(type_mapping, engines);
-            self.type_parameters.subst(type_mapping, engines);
+            self.fields.subst(ctx);
+            self.type_parameters.subst(ctx);
         }
     }
 }
@@ -273,7 +279,7 @@ impl OrdWithEngines for TyStructField {
 }
 
 impl SubstTypes for TyStructField {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.type_argument.subst_inner(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.type_argument.subst_inner(ctx)
     }
 }
diff --git a/sway-core/src/language/ty/declaration/trait.rs b/sway-core/src/language/ty/declaration/trait.rs
index 91d3bc5e8a3..f0c7ee24ff3 100644
--- a/sway-core/src/language/ty/declaration/trait.rs
+++ b/sway-core/src/language/ty/declaration/trait.rs
@@ -3,6 +3,7 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+use monomorphization::MonomorphizeHelper;
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::{Ident, Named, Span, Spanned};
 
@@ -13,16 +14,19 @@ use crate::{
     },
     engine_threading::*,
     has_changes,
-    language::{parsed, CallPath, Visibility},
+    language::{
+        parsed::{self, TraitDeclaration},
+        CallPath, Visibility,
+    },
     semantic_analysis::{
-        type_check_context::MonomorphizeHelper, TypeCheckAnalysis, TypeCheckAnalysisContext,
-        TypeCheckFinalization, TypeCheckFinalizationContext,
+        TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckFinalization,
+        TypeCheckFinalizationContext,
     },
     transform,
     type_system::*,
 };
 
-use super::TyDecl;
+use super::{TyDecl, TyDeclParsedType};
 
 #[derive(Clone, Debug)]
 pub struct TyTraitDecl {
@@ -38,6 +42,10 @@ pub struct TyTraitDecl {
     pub span: Span,
 }
 
+impl TyDeclParsedType for TyTraitDecl {
+    type ParsedType = TraitDeclaration;
+}
+
 #[derive(Clone, Debug)]
 pub enum TyTraitInterfaceItem {
     TraitFn(DeclRefTraitFn),
@@ -269,26 +277,26 @@ impl Spanned for TyTraitItem {
 }
 
 impl SubstTypes for TyTraitDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.type_parameters.subst(type_mapping, engines);
+            self.type_parameters.subst(ctx);
             self.interface_surface
                 .iter_mut()
                 .fold(HasChanges::No, |has_changes, item| match item {
                     TyTraitInterfaceItem::TraitFn(item_ref) => {
                         if let Some(new_item_ref) = item_ref
                             .clone()
-                            .subst_types_and_insert_new_with_parent(type_mapping, engines) {
+                            .subst_types_and_insert_new_with_parent(ctx) {
                             item_ref.replace_id(*new_item_ref.id());
                             HasChanges::Yes
-                        } else{
+                        } else {
                             HasChanges::No
                         }
                     }
                     TyTraitInterfaceItem::Constant(decl_ref) => {
                         if let Some(new_decl_ref) = decl_ref
                             .clone()
-                            .subst_types_and_insert_new(type_mapping, engines) {
+                            .subst_types_and_insert_new(ctx) {
                             decl_ref.replace_id(*new_decl_ref.id());
                             HasChanges::Yes
                         } else{
@@ -298,7 +306,7 @@ impl SubstTypes for TyTraitDecl {
                     TyTraitInterfaceItem::Type(decl_ref) => {
                         if let Some(new_decl_ref) = decl_ref
                             .clone()
-                            .subst_types_and_insert_new(type_mapping, engines) {
+                            .subst_types_and_insert_new(ctx) {
                             decl_ref.replace_id(*new_decl_ref.id());
                             HasChanges::Yes
                         } else{
@@ -310,7 +318,7 @@ impl SubstTypes for TyTraitDecl {
                 TyTraitItem::Fn(item_ref) => {
                     if let Some(new_item_ref) = item_ref
                         .clone()
-                        .subst_types_and_insert_new_with_parent(type_mapping, engines)
+                        .subst_types_and_insert_new_with_parent(ctx)
                     {
                         item_ref.replace_id(*new_item_ref.id());
                         HasChanges::Yes
@@ -321,7 +329,7 @@ impl SubstTypes for TyTraitDecl {
                 TyTraitItem::Constant(item_ref) => {
                     if let Some(new_decl_ref) = item_ref
                         .clone()
-                        .subst_types_and_insert_new_with_parent(type_mapping, engines)
+                        .subst_types_and_insert_new_with_parent(ctx)
                     {
                         item_ref.replace_id(*new_decl_ref.id());
                         HasChanges::Yes
@@ -332,7 +340,7 @@ impl SubstTypes for TyTraitDecl {
                 TyTraitItem::Type(item_ref) => {
                     if let Some(new_decl_ref) = item_ref
                         .clone()
-                        .subst_types_and_insert_new_with_parent(type_mapping, engines)
+                        .subst_types_and_insert_new_with_parent(ctx)
                     {
                         item_ref.replace_id(*new_decl_ref.id());
                         HasChanges::Yes
@@ -346,11 +354,11 @@ impl SubstTypes for TyTraitDecl {
 }
 
 impl SubstTypes for TyTraitItem {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         match self {
-            TyTraitItem::Fn(fn_decl) => fn_decl.subst(type_mapping, engines),
-            TyTraitItem::Constant(const_decl) => const_decl.subst(type_mapping, engines),
-            TyTraitItem::Type(type_decl) => type_decl.subst(type_mapping, engines),
+            TyTraitItem::Fn(fn_decl) => fn_decl.subst(ctx),
+            TyTraitItem::Constant(const_decl) => const_decl.subst(ctx),
+            TyTraitItem::Type(type_decl) => type_decl.subst(ctx),
         }
     }
 }
diff --git a/sway-core/src/language/ty/declaration/trait_fn.rs b/sway-core/src/language/ty/declaration/trait_fn.rs
index d643da86fbb..d9572af179f 100644
--- a/sway-core/src/language/ty/declaration/trait_fn.rs
+++ b/sway-core/src/language/ty/declaration/trait_fn.rs
@@ -3,13 +3,13 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+use monomorphization::MonomorphizeHelper;
 use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
     engine_threading::*,
     has_changes,
-    language::{ty::*, Purity},
-    semantic_analysis::type_check_context::MonomorphizeHelper,
+    language::{parsed::TraitFn, ty::*, Purity},
     transform,
     type_system::*,
 };
@@ -24,6 +24,10 @@ pub struct TyTraitFn {
     pub attributes: transform::AttributesMap,
 }
 
+impl TyDeclParsedType for TyTraitFn {
+    type ParsedType = TraitFn;
+}
+
 impl DebugWithEngines for TyTraitFn {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
         write!(
@@ -56,6 +60,23 @@ impl Spanned for TyTraitFn {
     }
 }
 
+impl IsConcrete for TyTraitFn {
+    fn is_concrete(&self, engines: &Engines) -> bool {
+        self.type_parameters()
+            .iter()
+            .all(|tp| tp.is_concrete(engines))
+            && self
+                .return_type
+                .type_id
+                .is_concrete(engines, TreatNumericAs::Concrete)
+            && self.parameters().iter().all(|t| {
+                t.type_argument
+                    .type_id
+                    .is_concrete(engines, TreatNumericAs::Concrete)
+            })
+    }
+}
+
 impl declaration::FunctionSignature for TyTraitFn {
     fn parameters(&self) -> &Vec<TyFunctionParameter> {
         &self.parameters
@@ -101,10 +122,10 @@ impl HashWithEngines for TyTraitFn {
 }
 
 impl SubstTypes for TyTraitFn {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.parameters.subst(type_mapping, engines);
-            self.return_type.subst(type_mapping, engines);
+            self.parameters.subst(ctx);
+            self.return_type.subst(ctx);
         }
     }
 }
diff --git a/sway-core/src/language/ty/declaration/trait_type.rs b/sway-core/src/language/ty/declaration/trait_type.rs
index d7d2368fcb2..24925afa457 100644
--- a/sway-core/src/language/ty/declaration/trait_type.rs
+++ b/sway-core/src/language/ty/declaration/trait_type.rs
@@ -5,7 +5,12 @@ use std::{
 
 use sway_types::{Ident, Named, Span, Spanned};
 
-use crate::{engine_threading::*, has_changes, transform, type_system::*};
+use crate::{
+    engine_threading::*, has_changes, language::parsed::TraitTypeDeclaration, transform,
+    type_system::*,
+};
+
+use super::TyDeclParsedType;
 
 #[derive(Clone, Debug)]
 pub struct TyTraitType {
@@ -16,6 +21,10 @@ pub struct TyTraitType {
     pub span: Span,
 }
 
+impl TyDeclParsedType for TyTraitType {
+    type ParsedType = TraitTypeDeclaration;
+}
+
 impl DebugWithEngines for TyTraitType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, _engines: &Engines) -> fmt::Result {
         write!(f, "{}", self.name)
@@ -28,6 +37,16 @@ impl Named for TyTraitType {
     }
 }
 
+impl IsConcrete for TyTraitType {
+    fn is_concrete(&self, engines: &Engines) -> bool {
+        if let Some(ty) = &self.ty {
+            ty.type_id.is_concrete(engines, TreatNumericAs::Concrete)
+        } else {
+            false
+        }
+    }
+}
+
 impl EqWithEngines for TyTraitType {}
 impl PartialEqWithEngines for TyTraitType {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
@@ -55,10 +74,10 @@ impl HashWithEngines for TyTraitType {
 }
 
 impl SubstTypes for TyTraitType {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.ty.subst(type_mapping, engines);
-            self.implementing_type.subst(type_mapping, engines);
+            self.ty.subst(ctx);
+            self.implementing_type.subst(ctx);
         }
     }
 }
diff --git a/sway-core/src/language/ty/declaration/type_alias.rs b/sway-core/src/language/ty/declaration/type_alias.rs
index ac72d15b322..e2e5844de3f 100644
--- a/sway-core/src/language/ty/declaration/type_alias.rs
+++ b/sway-core/src/language/ty/declaration/type_alias.rs
@@ -4,11 +4,13 @@ use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
     engine_threading::*,
-    language::{CallPath, Visibility},
+    language::{parsed::TypeAliasDeclaration, CallPath, Visibility},
     transform,
     type_system::*,
 };
 
+use super::TyDeclParsedType;
+
 #[derive(Clone, Debug)]
 pub struct TyTypeAliasDecl {
     pub name: Ident,
@@ -19,6 +21,10 @@ pub struct TyTypeAliasDecl {
     pub span: Span,
 }
 
+impl TyDeclParsedType for TyTypeAliasDecl {
+    type ParsedType = TypeAliasDeclaration;
+}
+
 impl Named for TyTypeAliasDecl {
     fn name(&self) -> &Ident {
         &self.name
@@ -51,8 +57,8 @@ impl HashWithEngines for TyTypeAliasDecl {
 }
 
 impl SubstTypes for TyTypeAliasDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.ty.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.ty.subst(ctx)
     }
 }
 
diff --git a/sway-core/src/language/ty/declaration/variable.rs b/sway-core/src/language/ty/declaration/variable.rs
index 87e6f808428..d7eb80ad7c6 100644
--- a/sway-core/src/language/ty/declaration/variable.rs
+++ b/sway-core/src/language/ty/declaration/variable.rs
@@ -1,15 +1,10 @@
 use std::hash::{Hash, Hasher};
 
-use sway_error::handler::{ErrorEmitted, Handler};
-use sway_types::Ident;
+use sway_types::{Ident, Named, Spanned};
 
 use crate::{
     engine_threading::*,
-    language::ty::*,
-    semantic_analysis::{
-        TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckFinalization,
-        TypeCheckFinalizationContext,
-    },
+    language::{parsed::VariableDeclaration, ty::*},
     type_system::*,
 };
 
@@ -22,6 +17,22 @@ pub struct TyVariableDecl {
     pub type_ascription: TypeArgument,
 }
 
+impl TyDeclParsedType for TyVariableDecl {
+    type ParsedType = VariableDeclaration;
+}
+
+impl Named for TyVariableDecl {
+    fn name(&self) -> &sway_types::BaseIdent {
+        &self.name
+    }
+}
+
+impl Spanned for TyVariableDecl {
+    fn span(&self) -> sway_types::Span {
+        self.name.span()
+    }
+}
+
 impl EqWithEngines for TyVariableDecl {}
 impl PartialEqWithEngines for TyVariableDecl {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
@@ -55,30 +66,9 @@ impl HashWithEngines for TyVariableDecl {
 }
 
 impl SubstTypes for TyVariableDecl {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.return_type.subst(type_mapping, engines);
-        self.type_ascription.subst(type_mapping, engines);
-        self.body.subst(type_mapping, engines)
-    }
-}
-
-impl TypeCheckAnalysis for TyVariableDecl {
-    fn type_check_analyze(
-        &self,
-        handler: &Handler,
-        ctx: &mut TypeCheckAnalysisContext,
-    ) -> Result<(), ErrorEmitted> {
-        self.body.type_check_analyze(handler, ctx)?;
-        Ok(())
-    }
-}
-
-impl TypeCheckFinalization for TyVariableDecl {
-    fn type_check_finalize(
-        &mut self,
-        handler: &Handler,
-        ctx: &mut TypeCheckFinalizationContext,
-    ) -> Result<(), ErrorEmitted> {
-        self.body.type_check_finalize(handler, ctx)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.return_type.subst(ctx);
+        self.type_ascription.subst(ctx);
+        self.body.subst(ctx)
     }
 }
diff --git a/sway-core/src/language/ty/expression/asm.rs b/sway-core/src/language/ty/expression/asm.rs
index 70227f5bb2d..04944125258 100644
--- a/sway-core/src/language/ty/expression/asm.rs
+++ b/sway-core/src/language/ty/expression/asm.rs
@@ -32,7 +32,7 @@ impl HashWithEngines for TyAsmRegisterDeclaration {
 }
 
 impl SubstTypes for TyAsmRegisterDeclaration {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.initializer.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.initializer.subst(ctx)
     }
 }
diff --git a/sway-core/src/language/ty/expression/contract.rs b/sway-core/src/language/ty/expression/contract.rs
index f5ef4662288..2bdec40421e 100644
--- a/sway-core/src/language/ty/expression/contract.rs
+++ b/sway-core/src/language/ty/expression/contract.rs
@@ -2,7 +2,8 @@ use crate::language::ty::*;
 
 #[derive(Clone, Debug)]
 pub struct ContractCallParams {
-    pub(crate) func_selector: [u8; 4],
+    // This is none in encoding V1
+    pub(crate) func_selector: Option<[u8; 4]>,
     pub(crate) contract_address: Box<TyExpression>,
     pub(crate) contract_caller: Box<TyExpression>,
 }
diff --git a/sway-core/src/language/ty/expression/expression.rs b/sway-core/src/language/ty/expression/expression.rs
index d940f40115c..15f57369007 100644
--- a/sway-core/src/language/ty/expression/expression.rs
+++ b/sway-core/src/language/ty/expression/expression.rs
@@ -1,7 +1,9 @@
 use std::{fmt, hash::Hasher};
 
 use sway_error::{
+    error::CompileError,
     handler::{ErrorEmitted, Handler},
+    type_error::TypeError,
     warning::{CompileWarning, Warning},
 };
 use sway_types::{Span, Spanned};
@@ -54,10 +56,10 @@ impl HashWithEngines for TyExpression {
 }
 
 impl SubstTypes for TyExpression {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.return_type.subst(type_mapping, engines);
-            self.expression.subst(type_mapping, engines);
+            self.return_type.subst(ctx);
+            self.expression.subst(ctx);
         }
     }
 }
@@ -108,6 +110,24 @@ impl TypeCheckAnalysis for TyExpression {
         handler: &Handler,
         ctx: &mut TypeCheckAnalysisContext,
     ) -> Result<(), ErrorEmitted> {
+        match &self.expression {
+            // Check literal "fits" into assigned typed.
+            TyExpressionVariant::Literal(Literal::Numeric(literal_value)) => {
+                let t = ctx.engines.te().get(self.return_type);
+                if let TypeInfo::UnsignedInteger(bits) = &*t {
+                    if bits.would_overflow(*literal_value) {
+                        handler.emit_err(CompileError::TypeError(TypeError::LiteralOverflow {
+                            expected: format!("{:?}", ctx.engines.help_out(t)),
+                            span: self.span.clone(),
+                        }));
+                    }
+                }
+            }
+            TyExpressionVariant::Array { .. } => {
+                self.as_array_unify_elements(handler, ctx.engines);
+            }
+            _ => {}
+        }
         self.expression.type_check_analyze(handler, ctx)
     }
 }
@@ -141,6 +161,7 @@ impl CollectTypesMetadata for TyExpression {
                 arguments,
                 fn_ref,
                 call_path,
+                type_binding,
                 ..
             } => {
                 for arg in arguments.iter() {
@@ -149,8 +170,30 @@ impl CollectTypesMetadata for TyExpression {
                 let function_decl = decl_engine.get_function(fn_ref);
 
                 ctx.call_site_push();
-                for type_parameter in &function_decl.type_parameters {
-                    ctx.call_site_insert(type_parameter.type_id, call_path.span())
+                for (idx, type_parameter) in function_decl.type_parameters.iter().enumerate() {
+                    ctx.call_site_insert(type_parameter.type_id, call_path.span());
+
+                    // Verify type arguments are concrete
+                    res.extend(
+                        type_parameter
+                            .type_id
+                            .collect_types_metadata(handler, ctx)?
+                            .into_iter()
+                            // try to use the caller span for better error messages
+                            .map(|x| match x {
+                                TypeMetadata::UnresolvedType(ident, original_span) => {
+                                    let span = type_binding
+                                        .as_ref()
+                                        .and_then(|type_binding| {
+                                            type_binding.type_arguments.as_slice().get(idx)
+                                        })
+                                        .map(|type_argument| Some(type_argument.span.clone()))
+                                        .unwrap_or(original_span);
+                                    TypeMetadata::UnresolvedType(ident, span)
+                                }
+                                x => x,
+                            }),
+                    );
                 }
 
                 for content in function_decl.body.contents.iter() {
@@ -173,10 +216,10 @@ impl CollectTypesMetadata for TyExpression {
             StructExpression {
                 fields,
                 instantiation_span,
-                struct_ref,
+                struct_id,
                 ..
             } => {
-                let struct_decl = decl_engine.get_struct(struct_ref);
+                let struct_decl = decl_engine.get_struct(struct_id);
                 for type_parameter in &struct_decl.type_parameters {
                     ctx.call_site_insert(type_parameter.type_id, instantiation_span.clone());
                 }
@@ -388,13 +431,13 @@ impl TyExpression {
 
         match &self.expression {
             TyExpressionVariant::StructExpression {
-                struct_ref,
+                struct_id,
                 instantiation_span,
                 ..
             } => {
-                let s = engines.de().get(struct_ref.id());
+                let struct_decl = engines.de().get(struct_id);
                 emit_warning_if_deprecated(
-                    &s.attributes,
+                    &struct_decl.attributes,
                     instantiation_span,
                     handler,
                     "deprecated struct",
@@ -404,10 +447,12 @@ impl TyExpression {
             TyExpressionVariant::FunctionApplication {
                 call_path, fn_ref, ..
             } => {
-                if let Some(TyDecl::ImplTrait(t)) = &engines.de().get(fn_ref).implementing_type {
+                if let Some(TyDecl::ImplSelfOrTrait(t)) =
+                    &engines.de().get(fn_ref).implementing_type
+                {
                     let t = &engines.de().get(&t.decl_id).implementing_for;
-                    if let TypeInfo::Struct(struct_ref) = &*engines.te().get(t.type_id) {
-                        let s = engines.de().get(struct_ref.id());
+                    if let TypeInfo::Struct(struct_id) = &*engines.te().get(t.type_id) {
+                        let s = engines.de().get(struct_id);
                         emit_warning_if_deprecated(
                             &s.attributes,
                             &call_path.span(),
@@ -421,4 +466,54 @@ impl TyExpression {
             _ => {}
         }
     }
+
+    pub fn as_intrinsic(&self) -> Option<&TyIntrinsicFunctionKind> {
+        match &self.expression {
+            TyExpressionVariant::IntrinsicFunction(v) => Some(v),
+            _ => None,
+        }
+    }
+
+    /// Unify elem_type with each element return type.
+    /// Must be called on arrays.
+    pub fn as_array_unify_elements(&self, handler: &Handler, engines: &Engines) {
+        let TyExpressionVariant::Array {
+            elem_type,
+            contents,
+        } = &self.expression
+        else {
+            unreachable!("Should only be called on Arrays")
+        };
+
+        let array_elem_type = engines.te().get(*elem_type);
+        if !matches!(&*array_elem_type, TypeInfo::Never) {
+            let unify = crate::type_system::unify::unifier::Unifier::new(
+                engines,
+                "",
+                unify::unifier::UnifyKind::Default,
+            );
+            for element in contents {
+                let element_type = engines.te().get(element.return_type);
+
+                // If the element is never, we do not need to check
+                if matches!(&*element_type, TypeInfo::Never) {
+                    continue;
+                }
+
+                let h = Handler::default();
+                unify.unify(&h, element.return_type, *elem_type, &element.span, true);
+
+                // unification error points to type that failed
+                // we want to report the element type instead
+                if h.has_errors() {
+                    handler.emit_err(CompileError::TypeError(TypeError::MismatchedType {
+                        expected: format!("{:?}", engines.help_out(&array_elem_type)),
+                        received: format!("{:?}", engines.help_out(element_type)),
+                        help_text: String::new(),
+                        span: element.span.clone(),
+                    }));
+                }
+            }
+        }
+    }
 }
diff --git a/sway-core/src/language/ty/expression/expression_variant.rs b/sway-core/src/language/ty/expression/expression_variant.rs
index fc02a806655..9908bb09f5b 100644
--- a/sway-core/src/language/ty/expression/expression_variant.rs
+++ b/sway-core/src/language/ty/expression/expression_variant.rs
@@ -33,8 +33,6 @@ pub enum TyExpressionVariant {
         type_binding: Option<TypeBinding<()>>,
         /// In case it is a method should contain a TypeId to either an enum, struct or a type alias.
         call_path_typeid: Option<TypeId>,
-        /// This tracks whether monomorphization has been deferred between compiler stages.
-        deferred_monomorphization: bool,
         contract_call_params: IndexMap<String, TyExpression>,
         contract_caller: Option<Box<TyExpression>>,
     },
@@ -71,7 +69,7 @@ pub enum TyExpressionVariant {
         index: Box<TyExpression>,
     },
     StructExpression {
-        struct_ref: DeclRef<DeclId<TyStructDecl>>,
+        struct_id: DeclId<TyStructDecl>,
         fields: Vec<TyStructExpressionField>,
         instantiation_span: Span,
         call_path_binding: TypeBinding<CallPath>,
@@ -174,6 +172,15 @@ pub enum TyExpressionVariant {
     Deref(Box<TyExpression>),
 }
 
+impl TyExpressionVariant {
+    pub fn as_literal(&self) -> Option<&Literal> {
+        match self {
+            TyExpressionVariant::Literal(v) => Some(v),
+            _ => None,
+        }
+    }
+}
+
 impl EqWithEngines for TyExpressionVariant {}
 impl PartialEqWithEngines for TyExpressionVariant {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
@@ -265,19 +272,21 @@ impl PartialEqWithEngines for TyExpressionVariant {
             ) => (**l_prefix).eq(&**r_prefix, ctx) && (**l_index).eq(&**r_index, ctx),
             (
                 Self::StructExpression {
-                    struct_ref: l_struct_ref,
+                    struct_id: l_struct_id,
                     fields: l_fields,
                     instantiation_span: l_span,
                     call_path_binding: _,
                 },
                 Self::StructExpression {
-                    struct_ref: r_struct_ref,
+                    struct_id: r_struct_id,
                     fields: r_fields,
                     instantiation_span: r_span,
                     call_path_binding: _,
                 },
             ) => {
-                l_struct_ref.eq(r_struct_ref, ctx) && l_fields.eq(r_fields, ctx) && l_span == r_span
+                PartialEqWithEngines::eq(&l_struct_id, &r_struct_id, ctx)
+                    && l_fields.eq(r_fields, ctx)
+                    && l_span == r_span
             }
             (Self::CodeBlock(l0), Self::CodeBlock(r0)) => l0.eq(r0, ctx),
             (
@@ -445,7 +454,6 @@ impl HashWithEngines for TyExpressionVariant {
                 selector: _,
                 type_binding: _,
                 call_path_typeid: _,
-                deferred_monomorphization: _,
                 ..
             } => {
                 call_path.hash(state);
@@ -499,14 +507,14 @@ impl HashWithEngines for TyExpressionVariant {
                 index.hash(state, engines);
             }
             Self::StructExpression {
-                struct_ref,
+                struct_id,
                 fields,
                 // these fields are not hashed because they aren't relevant/a
                 // reliable source of obj v. obj distinction
                 instantiation_span: _,
                 call_path_binding: _,
             } => {
-                struct_ref.hash(state, engines);
+                HashWithEngines::hash(&struct_id, state, engines);
                 fields.hash(state, engines);
             }
             Self::CodeBlock(contents) => {
@@ -641,7 +649,7 @@ impl HashWithEngines for TyExpressionVariant {
 }
 
 impl SubstTypes for TyExpressionVariant {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         use TyExpressionVariant::*;
         match self {
             Literal(..) => HasChanges::No,
@@ -651,69 +659,69 @@ impl SubstTypes for TyExpressionVariant {
                 ref mut call_path_typeid,
                 ..
             } => has_changes! {
-                arguments.subst(type_mapping, engines);
+                arguments.subst(ctx);
                 if let Some(new_decl_ref) = fn_ref
                     .clone()
-                    .subst_types_and_insert_new_with_parent(type_mapping, engines)
+                    .subst_types_and_insert_new_with_parent(ctx)
                 {
                     fn_ref.replace_id(*new_decl_ref.id());
                     HasChanges::Yes
                 } else {
                     HasChanges::No
                 };
-                call_path_typeid.subst(type_mapping, engines);
+                call_path_typeid.subst(ctx);
             },
             LazyOperator { lhs, rhs, .. } => has_changes! {
-                lhs.subst(type_mapping, engines);
-                rhs.subst(type_mapping, engines);
+                lhs.subst(ctx);
+                rhs.subst(ctx);
             },
-            ConstantExpression { decl, .. } => decl.subst(type_mapping, engines),
-            ConfigurableExpression { decl, .. } => decl.subst(type_mapping, engines),
+            ConstantExpression { decl, .. } => decl.subst(ctx),
+            ConfigurableExpression { decl, .. } => decl.subst(ctx),
             VariableExpression { .. } => HasChanges::No,
-            Tuple { fields } => fields.subst(type_mapping, engines),
+            Tuple { fields } => fields.subst(ctx),
             Array {
                 ref mut elem_type,
                 contents,
             } => has_changes! {
-                elem_type.subst(type_mapping, engines);
-                contents.subst(type_mapping, engines);
+                elem_type.subst(ctx);
+                contents.subst(ctx);
             },
             ArrayIndex { prefix, index } => has_changes! {
-                prefix.subst(type_mapping, engines);
-                index.subst(type_mapping, engines);
+                prefix.subst(ctx);
+                index.subst(ctx);
             },
             StructExpression {
-                struct_ref,
+                struct_id,
                 fields,
                 instantiation_span: _,
                 call_path_binding: _,
             } => has_changes! {
-                if let Some(new_struct_ref) = struct_ref
+                if let Some(new_struct_ref) = struct_id
                     .clone()
-                    .subst_types_and_insert_new(type_mapping, engines) {
-                    struct_ref.replace_id(*new_struct_ref.id());
+                    .subst_types_and_insert_new(ctx) {
+                    struct_id.replace_id(*new_struct_ref.id());
                     HasChanges::Yes
                 } else {
                     HasChanges::No
                 };
-                fields.subst(type_mapping, engines);
+                fields.subst(ctx);
             },
-            CodeBlock(block) => block.subst(type_mapping, engines),
+            CodeBlock(block) => block.subst(ctx),
             FunctionParameter => HasChanges::No,
-            MatchExp { desugared, .. } => desugared.subst(type_mapping, engines),
+            MatchExp { desugared, .. } => desugared.subst(ctx),
             IfExp {
                 condition,
                 then,
                 r#else,
             } => has_changes! {
-                condition.subst(type_mapping, engines);
-                then.subst(type_mapping, engines);
-                r#else.subst(type_mapping, engines);
+                condition.subst(ctx);
+                then.subst(ctx);
+                r#else.subst(ctx);
             },
             AsmExpression {
                 registers, //: Vec<TyAsmRegisterDeclaration>,
                 ..
-            } => registers.subst(type_mapping, engines),
+            } => registers.subst(ctx),
             // like a variable expression but it has multiple parts,
             // like looking up a field in a struct
             StructFieldAccess {
@@ -722,59 +730,59 @@ impl SubstTypes for TyExpressionVariant {
                 ref mut resolved_type_of_parent,
                 ..
             } => has_changes! {
-                resolved_type_of_parent.subst(type_mapping, engines);
-                field_to_access.subst(type_mapping, engines);
-                prefix.subst(type_mapping, engines);
+                resolved_type_of_parent.subst(ctx);
+                field_to_access.subst(ctx);
+                prefix.subst(ctx);
             },
             TupleElemAccess {
                 prefix,
                 ref mut resolved_type_of_parent,
                 ..
             } => has_changes! {
-                resolved_type_of_parent.subst(type_mapping, engines);
-                prefix.subst(type_mapping, engines);
+                resolved_type_of_parent.subst(ctx);
+                prefix.subst(ctx);
             },
             EnumInstantiation {
                 enum_ref, contents, ..
             } => has_changes! {
                 if let Some(new_enum_ref) = enum_ref
                     .clone()
-                    .subst_types_and_insert_new(type_mapping, engines)
+                    .subst_types_and_insert_new(ctx)
                 {
                     enum_ref.replace_id(*new_enum_ref.id());
                     HasChanges::Yes
                 } else {
                     HasChanges::No
                 };
-                contents.subst(type_mapping, engines);
+                contents.subst(ctx);
             },
-            AbiCast { address, .. } => address.subst(type_mapping, engines),
+            AbiCast { address, .. } => address.subst(ctx),
             // storage is never generic and cannot be monomorphized
             StorageAccess { .. } => HasChanges::No,
-            IntrinsicFunction(kind) => kind.subst(type_mapping, engines),
-            EnumTag { exp } => exp.subst(type_mapping, engines),
+            IntrinsicFunction(kind) => kind.subst(ctx),
+            EnumTag { exp } => exp.subst(ctx),
             UnsafeDowncast {
                 exp,
                 variant,
                 call_path_decl: _,
             } => has_changes! {
-                exp.subst(type_mapping, engines);
-                variant.subst(type_mapping, engines);
+                exp.subst(ctx);
+                variant.subst(ctx);
             },
             AbiName(_) => HasChanges::No,
             WhileLoop {
                 ref mut condition,
                 ref mut body,
             } => {
-                condition.subst(type_mapping, engines);
-                body.subst(type_mapping, engines)
+                condition.subst(ctx);
+                body.subst(ctx)
             }
-            ForLoop { ref mut desugared } => desugared.subst(type_mapping, engines),
+            ForLoop { ref mut desugared } => desugared.subst(ctx),
             Break => HasChanges::No,
             Continue => HasChanges::No,
-            Reassignment(reassignment) => reassignment.subst(type_mapping, engines),
-            ImplicitReturn(expr) | Return(expr) => expr.subst(type_mapping, engines),
-            Ref(exp) | Deref(exp) => exp.subst(type_mapping, engines),
+            Reassignment(reassignment) => reassignment.subst(ctx),
+            ImplicitReturn(expr) | Return(expr) => expr.subst(ctx),
+            Ref(exp) | Deref(exp) => exp.subst(ctx),
         }
     }
 }
@@ -893,7 +901,7 @@ impl ReplaceDecls for TyExpressionVariant {
                     Ok(has_changes)
                 }
                 StructExpression {
-                    struct_ref: _,
+                    struct_id: _,
                     fields,
                     instantiation_span: _,
                     call_path_binding: _,
@@ -999,7 +1007,9 @@ impl TypeCheckAnalysis for TyExpressionVariant {
     ) -> Result<(), ErrorEmitted> {
         match self {
             TyExpressionVariant::Literal(_) => {}
-            TyExpressionVariant::FunctionApplication { fn_ref, .. } => {
+            TyExpressionVariant::FunctionApplication {
+                fn_ref, arguments, ..
+            } => {
                 let fn_decl_id = ctx.get_normalized_fn_node_id(fn_ref.id());
 
                 let fn_node = ctx.get_node_for_fn_decl(&fn_decl_id);
@@ -1013,6 +1023,22 @@ impl TypeCheckAnalysis for TyExpressionVariant {
                         let _ = fn_decl_id.type_check_analyze(handler, ctx);
                     }
                 }
+
+                // Unify arguments that are still not concrete
+                let decl = ctx.engines.de().get(fn_ref.id());
+
+                use crate::type_system::unify::unifier::*;
+                let unifier = Unifier::new(ctx.engines, "", UnifyKind::Default);
+
+                for (decl_param, arg) in decl.parameters.iter().zip(arguments.iter()) {
+                    unifier.unify(
+                        handler,
+                        arg.1.return_type,
+                        decl_param.type_argument.type_id,
+                        &Span::dummy(),
+                        false,
+                    );
+                }
             }
             TyExpressionVariant::LazyOperator { lhs, rhs, .. } => {
                 lhs.type_check_analyze(handler, ctx)?;
@@ -1121,15 +1147,7 @@ impl TypeCheckFinalization for TyExpressionVariant {
         handler.scope(|handler| {
             match self {
                 TyExpressionVariant::Literal(_) => {}
-                TyExpressionVariant::FunctionApplication {
-                    arguments,
-                    deferred_monomorphization,
-                    ..
-                } => {
-                    // If the function application was deferred we need to monomorphize it here.
-                    // But at the moment monomorphization is fully resolved before type check finalization.
-                    assert!(!(*deferred_monomorphization));
-
+                TyExpressionVariant::FunctionApplication { arguments, .. } => {
                     for (_, arg) in arguments.iter_mut() {
                         let _ = arg.type_check_finalize(handler, ctx);
                     }
@@ -1357,8 +1375,8 @@ fn find_const_decl_from_impl(
     const_decl: &TyConstantDecl,
 ) -> Option<TyConstantDecl> {
     match implementing_type {
-        TyDecl::ImplTrait(ImplTrait { decl_id, .. }) => {
-            let impl_trait = decl_engine.get_impl_trait(&decl_id.clone());
+        TyDecl::ImplSelfOrTrait(ImplSelfOrTrait { decl_id, .. }) => {
+            let impl_trait = decl_engine.get_impl_self_or_trait(&decl_id.clone());
             impl_trait
                 .items
                 .iter()
@@ -1412,8 +1430,9 @@ impl DebugWithEngines for TyExpressionVariant {
             }
             TyExpressionVariant::Array { .. } => "array".into(),
             TyExpressionVariant::ArrayIndex { .. } => "[..]".into(),
-            TyExpressionVariant::StructExpression { struct_ref, .. } => {
-                format!("\"{}\" struct init", struct_ref.name().as_str())
+            TyExpressionVariant::StructExpression { struct_id, .. } => {
+                let decl = engines.de().get(struct_id);
+                format!("\"{}\" struct init", decl.name().as_str())
             }
             TyExpressionVariant::CodeBlock(_) => "code block entry".into(),
             TyExpressionVariant::FunctionParameter => "fn param access".into(),
diff --git a/sway-core/src/language/ty/expression/intrinsic_function.rs b/sway-core/src/language/ty/expression/intrinsic_function.rs
index a82ec310f9f..4fb4e72c3bc 100644
--- a/sway-core/src/language/ty/expression/intrinsic_function.rs
+++ b/sway-core/src/language/ty/expression/intrinsic_function.rs
@@ -73,10 +73,10 @@ impl HashWithEngines for TyIntrinsicFunctionKind {
 }
 
 impl SubstTypes for TyIntrinsicFunctionKind {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.arguments.subst(type_mapping, engines);
-            self.type_arguments.subst(type_mapping, engines);
+            self.arguments.subst(ctx);
+            self.type_arguments.subst(ctx);
         }
     }
 }
@@ -118,9 +118,10 @@ impl CollectTypesMetadata for TyIntrinsicFunctionKind {
                 types_metadata.push(TypeMetadata::LoggedType(
                     LogId::new(logged_type.get_abi_type_str(
                         &AbiStrContext {
-                            program_name: Some(ctx.program_name.clone()),
+                            program_name: ctx.program_name.clone(),
                             abi_with_callpaths: true,
                             abi_with_fully_specified_types: true,
+                            abi_root_type_without_generic_type_parameters: false,
                         },
                         ctx.engines,
                         logged_type,
diff --git a/sway-core/src/language/ty/expression/reassignment.rs b/sway-core/src/language/ty/expression/reassignment.rs
index d643ef63227..358855a0102 100644
--- a/sway-core/src/language/ty/expression/reassignment.rs
+++ b/sway-core/src/language/ty/expression/reassignment.rs
@@ -114,14 +114,14 @@ impl HashWithEngines for TyReassignment {
 }
 
 impl SubstTypes for TyReassignmentTarget {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
             match self {
-                TyReassignmentTarget::Deref(exp) => exp.subst(type_mapping, engines),
+                TyReassignmentTarget::Deref(exp) => exp.subst(ctx),
                 TyReassignmentTarget::ElementAccess { base_type, indices, .. } => {
                     has_changes! {
-                        base_type.subst(type_mapping, engines);
-                        indices.subst(type_mapping, engines);
+                        base_type.subst(ctx);
+                        indices.subst(ctx);
                     }
                 }
             };
@@ -130,10 +130,10 @@ impl SubstTypes for TyReassignmentTarget {
 }
 
 impl SubstTypes for TyReassignment {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.lhs.subst(type_mapping, engines);
-            self.rhs.subst(type_mapping, engines);
+            self.lhs.subst(ctx);
+            self.rhs.subst(ctx);
         }
     }
 }
@@ -330,10 +330,10 @@ impl HashWithEngines for ProjectionKind {
 }
 
 impl SubstTypes for ProjectionKind {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         use ProjectionKind::*;
         match self {
-            ArrayIndex { index, .. } => index.subst(type_mapping, engines),
+            ArrayIndex { index, .. } => index.subst(ctx),
             _ => HasChanges::No,
         }
     }
diff --git a/sway-core/src/language/ty/expression/scrutinee.rs b/sway-core/src/language/ty/expression/scrutinee.rs
index 240865dcda3..68c51af26eb 100644
--- a/sway-core/src/language/ty/expression/scrutinee.rs
+++ b/sway-core/src/language/ty/expression/scrutinee.rs
@@ -20,7 +20,6 @@ pub enum TyScrutineeVariant {
     Literal(Literal),
     Variable(Ident),
     Constant(Ident, Literal, TyConstantDecl),
-    Configurable(Ident, Literal, TyConfigurableDecl),
     StructScrutinee {
         struct_ref: DeclRefStruct,
         fields: Vec<TyStructScrutineeField>,
diff --git a/sway-core/src/language/ty/expression/struct_exp_field.rs b/sway-core/src/language/ty/expression/struct_exp_field.rs
index 7e6f49ac415..5f879640fb3 100644
--- a/sway-core/src/language/ty/expression/struct_exp_field.rs
+++ b/sway-core/src/language/ty/expression/struct_exp_field.rs
@@ -33,8 +33,8 @@ impl HashWithEngines for TyStructExpressionField {
 }
 
 impl SubstTypes for TyStructExpressionField {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.value.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.value.subst(ctx)
     }
 }
 
diff --git a/sway-core/src/language/ty/module.rs b/sway-core/src/language/ty/module.rs
index 21bc45eb6cf..740c7e14588 100644
--- a/sway-core/src/language/ty/module.rs
+++ b/sway-core/src/language/ty/module.rs
@@ -4,9 +4,8 @@ use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::Span;
 
 use crate::{
-    decl_engine::{DeclEngine, DeclRef, DeclRefFunction},
-    language::ModName,
-    language::{ty::*, HasModule, HasSubmodules},
+    decl_engine::{DeclEngine, DeclEngineGet, DeclId, DeclRef, DeclRefFunction},
+    language::{ty::*, HasModule, HasSubmodules, ModName},
     semantic_analysis::namespace,
     transform::{self, AllowDeprecatedState},
     Engines,
@@ -21,9 +20,62 @@ pub struct TyModule {
     pub attributes: transform::AttributesMap,
 }
 
+impl TyModule {
+    /// Iter on all constants in this module, which means, globals constants and
+    /// local constants, but it does not enter into submodules.
+    pub fn iter_constants(&self, de: &DeclEngine) -> Vec<ConstantDecl> {
+        fn inside_code_block(de: &DeclEngine, block: &TyCodeBlock) -> Vec<ConstantDecl> {
+            block
+                .contents
+                .iter()
+                .flat_map(|node| inside_ast_node(de, node))
+                .collect::<Vec<_>>()
+        }
+
+        fn inside_ast_node(de: &DeclEngine, node: &TyAstNode) -> Vec<ConstantDecl> {
+            match &node.content {
+                TyAstNodeContent::Declaration(decl) => match decl {
+                    TyDecl::ConstantDecl(decl) => {
+                        vec![decl.clone()]
+                    }
+                    TyDecl::FunctionDecl(decl) => {
+                        let decl = de.get(&decl.decl_id);
+                        inside_code_block(de, &decl.body)
+                    }
+                    TyDecl::ImplSelfOrTrait(decl) => {
+                        let decl = de.get(&decl.decl_id);
+                        decl.items
+                            .iter()
+                            .flat_map(|item| match item {
+                                TyTraitItem::Fn(decl) => {
+                                    let decl = de.get(decl.id());
+                                    inside_code_block(de, &decl.body)
+                                }
+                                TyTraitItem::Constant(decl) => {
+                                    vec![ConstantDecl {
+                                        decl_id: *decl.id(),
+                                    }]
+                                }
+                                _ => vec![],
+                            })
+                            .collect()
+                    }
+                    _ => vec![],
+                },
+                _ => vec![],
+            }
+        }
+
+        self.all_nodes
+            .iter()
+            .flat_map(|node| inside_ast_node(de, node))
+            .collect::<Vec<_>>()
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct TySubmodule {
-    pub module: TyModule,
+    pub module: Arc<TyModule>,
     pub mod_name_span: Span,
 }
 
@@ -71,12 +123,22 @@ impl TyModule {
     pub fn contract_fns<'a: 'b, 'b>(
         &'b self,
         engines: &'a Engines,
-    ) -> impl '_ + Iterator<Item = DeclRefFunction> {
+    ) -> impl '_ + Iterator<Item = DeclId<TyFunctionDecl>> {
         self.all_nodes
             .iter()
             .flat_map(move |node| node.contract_fns(engines))
     }
 
+    /// All contract supertrait functions within this module.
+    pub fn contract_supertrait_fns<'a: 'b, 'b>(
+        &'b self,
+        engines: &'a Engines,
+    ) -> impl '_ + Iterator<Item = DeclId<TyFunctionDecl>> {
+        self.all_nodes
+            .iter()
+            .flat_map(move |node| node.contract_supertrait_fns(engines))
+    }
+
     pub(crate) fn check_deprecated(
         &self,
         engines: &Engines,
diff --git a/sway-core/src/language/ty/program.rs b/sway-core/src/language/ty/program.rs
index 968407d6fd6..b2257451574 100644
--- a/sway-core/src/language/ty/program.rs
+++ b/sway-core/src/language/ty/program.rs
@@ -72,7 +72,6 @@ impl TyProgram {
         let decl_engine = engines.de();
 
         // Validate all submodules
-        let mut non_configurables_constants = vec![];
         let mut configurables = vec![];
         for (_, submodule) in &root.submodules {
             match Self::validate_root(
@@ -114,13 +113,6 @@ impl TyProgram {
 
                     declarations.push(TyDecl::FunctionDecl(FunctionDecl { decl_id: *decl_id }));
                 }
-                TyAstNodeContent::Declaration(TyDecl::ConstantDecl(ConstantDecl {
-                    decl_id,
-                    ..
-                })) => {
-                    let decl = (*decl_engine.get_constant(decl_id)).clone();
-                    non_configurables_constants.push(decl);
-                }
                 TyAstNodeContent::Declaration(TyDecl::ConfigurableDecl(ConfigurableDecl {
                     decl_id,
                     ..
@@ -131,9 +123,12 @@ impl TyProgram {
                 // ABI entries are all functions declared in impl_traits on the contract type
                 // itself, except for ABI supertraits, which do not expose their methods to
                 // the user
-                TyAstNodeContent::Declaration(TyDecl::ImplTrait(ImplTrait { decl_id, .. })) => {
-                    let impl_trait_decl = decl_engine.get_impl_trait(decl_id);
-                    let TyImplTrait {
+                TyAstNodeContent::Declaration(TyDecl::ImplSelfOrTrait(ImplSelfOrTrait {
+                    decl_id,
+                    ..
+                })) => {
+                    let impl_trait_decl = decl_engine.get_impl_self_or_trait(decl_id);
+                    let TyImplSelfOrTrait {
                         items,
                         implementing_for,
                         trait_decl_ref,
@@ -339,18 +334,36 @@ impl TyProgram {
                     (mains[0], mains[0])
                 };
 
-                // A script must not return a `raw_ptr` or any type aggregating a `raw_slice`.
-                // Directly returning a `raw_slice` is allowed, which will be just mapped to a RETD.
-                // TODO: Allow returning nested `raw_slice`s when our spec supports encoding DSTs.
-                let main_fn = decl_engine.get(&main_fn_id);
-                for p in main_fn.parameters() {
+                // On encoding v0, we cannot accept/return ptrs, slices etc...
+                if !experimental.new_encoding {
+                    let main_fn = decl_engine.get(&main_fn_id);
+                    for p in main_fn.parameters() {
+                        if let Some(error) = get_type_not_allowed_error(
+                            engines,
+                            p.type_argument.type_id,
+                            &p.type_argument,
+                            |t| match t {
+                                TypeInfo::StringSlice => {
+                                    Some(TypeNotAllowedReason::StringSliceInMainParameters)
+                                }
+                                TypeInfo::RawUntypedSlice => {
+                                    Some(TypeNotAllowedReason::NestedSliceReturnNotAllowedInMain)
+                                }
+                                _ => None,
+                            },
+                        ) {
+                            handler.emit_err(error);
+                        }
+                    }
+
+                    // Check main return type is valid
                     if let Some(error) = get_type_not_allowed_error(
                         engines,
-                        p.type_argument.type_id,
-                        &p.type_argument,
+                        main_fn.return_type.type_id,
+                        &main_fn.return_type,
                         |t| match t {
                             TypeInfo::StringSlice => {
-                                Some(TypeNotAllowedReason::StringSliceInMainParameters)
+                                Some(TypeNotAllowedReason::StringSliceInMainReturn)
                             }
                             TypeInfo::RawUntypedSlice => {
                                 Some(TypeNotAllowedReason::NestedSliceReturnNotAllowedInMain)
@@ -358,31 +371,13 @@ impl TyProgram {
                             _ => None,
                         },
                     ) {
-                        handler.emit_err(error);
-                    }
-                }
-
-                // Check main return type is valid
-                if let Some(error) = get_type_not_allowed_error(
-                    engines,
-                    main_fn.return_type.type_id,
-                    &main_fn.return_type,
-                    |t| match t {
-                        TypeInfo::StringSlice => {
-                            Some(TypeNotAllowedReason::StringSliceInMainReturn)
+                        // Let main return `raw_slice` directly
+                        if !matches!(
+                            &*engines.te().get(main_fn.return_type.type_id),
+                            TypeInfo::RawUntypedSlice
+                        ) {
+                            handler.emit_err(error);
                         }
-                        TypeInfo::RawUntypedSlice => {
-                            Some(TypeNotAllowedReason::NestedSliceReturnNotAllowedInMain)
-                        }
-                        _ => None,
-                    },
-                ) {
-                    // Let main return `raw_slice` directly
-                    if !matches!(
-                        &*engines.te().get(main_fn.return_type.type_id),
-                        TypeInfo::RawUntypedSlice
-                    ) {
-                        handler.emit_err(error);
                     }
                 }
 
@@ -401,6 +396,7 @@ impl TyProgram {
                 &c.type_ascription,
                 |t| match t {
                     TypeInfo::StringSlice => Some(TypeNotAllowedReason::StringSliceInConfigurables),
+                    TypeInfo::Slice(_) => Some(TypeNotAllowedReason::SliceInConst),
                     _ => None,
                 },
             ) {
@@ -408,16 +404,18 @@ impl TyProgram {
             }
         }
 
-        for c in non_configurables_constants.iter() {
-            if let Some(error) = get_type_not_allowed_error(
-                engines,
-                c.return_type,
-                &c.type_ascription,
-                |t| match t {
-                    TypeInfo::StringSlice => Some(TypeNotAllowedReason::StringSliceInConst),
-                    _ => None,
-                },
-            ) {
+        // verify all constants
+        for decl in root.iter_constants(decl_engine).iter() {
+            let decl = decl_engine.get_constant(&decl.decl_id);
+            let e =
+                get_type_not_allowed_error(engines, decl.return_type, &decl.type_ascription, |t| {
+                    match t {
+                        TypeInfo::StringSlice => Some(TypeNotAllowedReason::StringSliceInConst),
+                        TypeInfo::Slice(_) => Some(TypeNotAllowedReason::SliceInConst),
+                        _ => None,
+                    }
+                });
+            if let Some(error) = e {
                 handler.emit_err(error);
             }
         }
@@ -499,7 +497,7 @@ impl CollectTypesMetadata for TyProgram {
                 for module in std::iter::once(&self.root).chain(
                     self.root
                         .submodules_recursive()
-                        .map(|(_, submod)| &submod.module),
+                        .map(|(_, submod)| &*submod.module),
                 ) {
                     for node in module.all_nodes.iter() {
                         let is_generic_function = node.is_generic_function(decl_engine);
@@ -528,7 +526,7 @@ impl CollectTypesMetadata for TyProgram {
         for module in std::iter::once(&self.root).chain(
             self.root
                 .submodules_recursive()
-                .map(|(_, submod)| &submod.module),
+                .map(|(_, submod)| &*submod.module),
         ) {
             for node in module.all_nodes.iter() {
                 if node.is_test_function(decl_engine) {
diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
index 153358ca0cf..fcc524ce8a0 100644
--- a/sway-core/src/lib.rs
+++ b/sway-core/src/lib.rs
@@ -1,3 +1,5 @@
+#![recursion_limit = "256"]
+
 #[macro_use]
 pub mod error;
 
@@ -33,7 +35,7 @@ use control_flow_analysis::ControlFlowGraph;
 pub use debug_generation::write_dwarf;
 use indexmap::IndexMap;
 use metadata::MetadataManager;
-use query_engine::{ModuleCacheKey, ModulePath, ProgramsCacheEntry};
+use query_engine::{ModuleCacheKey, ModuleCommonInfo, ParsedModuleInfo, ProgramsCacheEntry};
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
@@ -236,7 +238,7 @@ fn parse_in_memory(
 
 pub struct Submodule {
     name: Ident,
-    path: ModulePath,
+    path: Arc<PathBuf>,
     lexed: lexed::LexedSubmodule,
     parsed: parsed::ParseSubmodule,
 }
@@ -259,7 +261,6 @@ fn parse_submodules(
 ) -> Submodules {
     // Assume the happy path, so there'll be as many submodules as dependencies, but no more.
     let mut submods = Vec::with_capacity(module.submodules().count());
-
     module.submodules().for_each(|submod| {
         // Read the source code from the dependency.
         // If we cannot, record as an error, but continue with other files.
@@ -275,7 +276,6 @@ fn parse_submodules(
                 return;
             }
         };
-
         if let Ok(ParsedModuleTree {
             tree_type: kind,
             lexed_module,
@@ -318,7 +318,6 @@ fn parse_submodules(
             submods.push(submodule);
         }
     });
-
     submods
 }
 
@@ -411,15 +410,19 @@ fn parse_module_tree(
     let version = lsp_mode
         .and_then(|lsp| lsp.file_versions.get(path.as_ref()).copied())
         .unwrap_or(None);
-    let cache_entry = ModuleCacheEntry {
-        path,
-        modified_time,
-        hash,
-        dependencies,
+
+    let common_info = ModuleCommonInfo {
+        path: path.clone(),
         include_tests,
+        dependencies,
+        hash,
+    };
+    let parsed_info = ParsedModuleInfo {
+        modified_time,
         version,
     };
-    query_engine.insert_parse_module_cache_entry(cache_entry);
+    let cache_entry = ModuleCacheEntry::new(common_info, parsed_info);
+    query_engine.update_or_insert_parsed_module_cache_entry(cache_entry);
 
     Ok(ParsedModuleTree {
         tree_type: kind,
@@ -428,59 +431,89 @@ fn parse_module_tree(
     })
 }
 
-fn is_parse_module_cache_up_to_date(
+/// Checks if the typed module cache for a given path is up to date.
+///
+/// This function determines whether the cached typed representation of a module
+/// is still valid based on file versions and dependencies.
+///
+/// Note: This functionality is currently only supported when the compiler is
+/// initiated from the language server.
+pub(crate) fn is_ty_module_cache_up_to_date(
     engines: &Engines,
     path: &Arc<PathBuf>,
     include_tests: bool,
     build_config: Option<&BuildConfig>,
 ) -> bool {
-    let query_engine = engines.qe();
+    let cache = engines.qe().module_cache.read();
     let key = ModuleCacheKey::new(path.clone(), include_tests);
-    let entry = query_engine.get_parse_module_cache_entry(&key);
-    match entry {
-        Some(entry) => {
-            // Let's check if we can re-use the dependency information
-            // we got from the cache.
+    cache.get(&key).map_or(false, |entry| {
+        entry.typed.as_ref().map_or(false, |typed| {
+            // Check if the cache is up to date based on file versions
             let cache_up_to_date = build_config
-                .as_ref()
                 .and_then(|x| x.lsp_mode.as_ref())
-                .and_then(|lsp| {
-                    // First try to get the file version from lsp if it exists
-                    lsp.file_versions.get(path.as_ref())
-                })
-                .map_or_else(
-                    || {
-                        // Otherwise we can safely read the file from disk here, as the LSP has not modified it, or we are not in LSP mode.
-                        // Check if the file has been modified or if its hash is the same as the last compilation
-                        let modified_time = std::fs::metadata(path.as_path())
-                            .ok()
-                            .and_then(|m| m.modified().ok());
-                        entry.modified_time == modified_time || {
-                            let src = std::fs::read_to_string(path.as_path()).unwrap();
-                            let mut hasher = DefaultHasher::new();
-                            src.hash(&mut hasher);
-                            let hash = hasher.finish();
-                            hash == entry.hash
-                        }
-                    },
-                    |version| {
-                        // The cache is invalid if the lsp version is greater than the last compilation
-                        !version.map_or(false, |v| v > entry.version.unwrap_or(0))
-                    },
-                );
-
-            // Look at the dependencies recursively to make sure they have not been
-            // modified either.
-            if cache_up_to_date {
-                entry.dependencies.iter().all(|path| {
-                    is_parse_module_cache_up_to_date(engines, path, include_tests, build_config)
+                .and_then(|lsp| lsp.file_versions.get(path.as_ref()))
+                .map_or(true, |version| {
+                    version.map_or(true, |v| typed.version.map_or(false, |tv| v <= tv))
+                });
+
+            // If the cache is up to date, recursively check all dependencies
+            cache_up_to_date
+                && entry.common.dependencies.iter().all(|dep_path| {
+                    is_ty_module_cache_up_to_date(engines, dep_path, include_tests, build_config)
                 })
-            } else {
-                false
-            }
-        }
-        None => false,
-    }
+        })
+    })
+}
+
+/// Checks if the parsed module cache for a given path is up to date.
+///
+/// This function determines whether the cached parsed representation of a module
+/// is still valid based on file versions, modification times, or content hashes.
+pub(crate) fn is_parse_module_cache_up_to_date(
+    engines: &Engines,
+    path: &Arc<PathBuf>,
+    include_tests: bool,
+    build_config: Option<&BuildConfig>,
+) -> bool {
+    let cache = engines.qe().module_cache.read();
+    let key = ModuleCacheKey::new(path.clone(), include_tests);
+    cache.get(&key).map_or(false, |entry| {
+        // Determine if the cached dependency information is still valid
+        let cache_up_to_date = build_config
+            .and_then(|x| x.lsp_mode.as_ref())
+            .and_then(|lsp| lsp.file_versions.get(path.as_ref()))
+            .map_or_else(
+                || {
+                    // If LSP mode is not active or file version is unavailable, fall back to filesystem checks.
+                    let modified_time = std::fs::metadata(path.as_path())
+                        .ok()
+                        .and_then(|m| m.modified().ok());
+                    // Check if modification time matches, or if not, compare file content hash
+                    entry.parsed.modified_time == modified_time || {
+                        let src = std::fs::read_to_string(path.as_path()).unwrap();
+                        let mut hasher = DefaultHasher::new();
+                        src.hash(&mut hasher);
+                        hasher.finish() == entry.common.hash
+                    }
+                },
+                |version| {
+                    // Determine if the parse cache is up-to-date in LSP mode:
+                    // - If there's no LSP file version (version is None), consider the cache up-to-date.
+                    // - If there is an LSP file version:
+                    //   - If there's no cached version (entry.parsed.version is None), the cache is outdated.
+                    //   - If there's a cached version, compare them: cache is up-to-date if the LSP file version
+                    //     is not greater than the cached version.
+                    version.map_or(true, |v| entry.parsed.version.map_or(false, |ev| v <= ev))
+                },
+            );
+
+        // Checks if the typed module cache for a given path is up to date// If the cache is up to date, recursively check all dependencies to make sure they have not been
+        // modified either.
+        cache_up_to_date
+            && entry.common.dependencies.iter().all(|dep_path| {
+                is_parse_module_cache_up_to_date(engines, dep_path, include_tests, build_config)
+            })
+    })
 }
 
 fn module_path(
@@ -520,7 +553,7 @@ pub fn parsed_to_ast(
     handler: &Handler,
     engines: &Engines,
     parse_program: &mut parsed::ParseProgram,
-    initial_namespace: namespace::Root,
+    initial_namespace: &mut namespace::Root,
     build_config: Option<&BuildConfig>,
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
@@ -537,7 +570,7 @@ pub fn parsed_to_ast(
 
     let namespace = Namespace::init_root(initial_namespace);
     // Collect the program symbols.
-    let _collection_ctx =
+    let mut collection_ctx =
         ty::TyProgram::collect(handler, engines, parse_program, namespace.clone())?;
 
     // Type check the program.
@@ -545,6 +578,7 @@ pub fn parsed_to_ast(
         handler,
         engines,
         parse_program,
+        &mut collection_ctx,
         namespace,
         package_name,
         build_config,
@@ -691,18 +725,18 @@ pub fn compile_to_ast(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Root,
+    initial_namespace: &mut namespace::Root,
     build_config: Option<&BuildConfig>,
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
 ) -> Result<Programs, ErrorEmitted> {
     check_should_abort(handler, retrigger_compilation.clone())?;
+
     let query_engine = engines.qe();
     let mut metrics = PerformanceData::default();
     if let Some(config) = build_config {
         let path = config.canonical_root_module();
         let include_tests = config.include_tests;
-
         // Check if we can re-use the data in the cache.
         if is_parse_module_cache_up_to_date(engines, &path, include_tests, build_config) {
             let mut entry = query_engine.get_programs_cache_entry(&path).unwrap();
@@ -783,7 +817,7 @@ pub fn compile_to_asm(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Root,
+    initial_namespace: &mut namespace::Root,
     build_config: &BuildConfig,
     package_name: &str,
 ) -> Result<CompiledAsm, ErrorEmitted> {
@@ -944,7 +978,7 @@ pub fn compile_to_bytecode(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Root,
+    initial_namespace: &mut namespace::Root,
     build_config: &BuildConfig,
     source_map: &mut SourceMap,
     package_name: &str,
diff --git a/sway-core/src/metadata.rs b/sway-core/src/metadata.rs
index b55d03ed1a7..86da8c72ff4 100644
--- a/sway-core/src/metadata.rs
+++ b/sway-core/src/metadata.rs
@@ -1,43 +1,48 @@
 use crate::{
     decl_engine::DeclId,
-    language::{ty::TyFunctionDecl, Inline, Purity},
+    language::{ty::TyFunctionDecl, CallPath, Inline, Purity},
 };
 
 use sway_ir::{Context, MetadataIndex, Metadatum, Value};
-use sway_types::{SourceId, Span};
+use sway_types::{Ident, SourceId, Span, Spanned};
 
 use std::{collections::HashMap, path::PathBuf, sync::Arc};
 
-/// IR metadata needs to be consistent between IR generation (converting Spans, etc. to metadata)
+/// IR metadata needs to be consistent between IR generation (converting [Span]s, etc. to metadata)
 /// and ASM generation (converting the metadata back again).  Here we consolidate all of
 /// `sway-core`s metadata needs into a single place to enable that consistency.
 ///
-/// The [`MetadataManager`] also does its best to reduce redundancy by caching certain common
+/// The [MetadataManager] also does its best to reduce redundancy by caching certain common
 /// elements, such as source paths and storage attributes, and to avoid recreating the same
 /// indices repeatedly.
 
 #[derive(Default)]
 pub(crate) struct MetadataManager {
+    // We want to be able to store more then one `Span` per `MetadataIndex`.
+    // E.g., storing the span of the function name, and the whole function declaration.
+    // The spans differ then by the tag property of their `Metadatum::Struct`.
+    // We could cache all such spans in a single `HashMap` where the key would be (Span, tag).
+    // But since the vast majority of stored spans will be tagged with the generic "span" tag,
+    // and only a few elements will have additional spans in their `MetadataIndex`, it is
+    // more efficient to provide two separate caches, one for the spans tagged with "span",
+    // and one for all other spans, tagged with arbitrary tags.
+    /// Holds [Span]s tagged with "span".
     md_span_cache: HashMap<MetadataIndex, Span>,
+    /// Holds [Span]s tagged with an arbitrary tag.
+    md_tagged_span_cache: HashMap<MetadataIndex, (Span, &'static str)>,
     md_file_loc_cache: HashMap<MetadataIndex, (Arc<PathBuf>, Arc<str>)>,
-    md_storage_op_cache: HashMap<MetadataIndex, StorageOperation>,
+    md_purity_cache: HashMap<MetadataIndex, Purity>,
     md_inline_cache: HashMap<MetadataIndex, Inline>,
     md_test_decl_index_cache: HashMap<MetadataIndex, DeclId<TyFunctionDecl>>,
 
     span_md_cache: HashMap<Span, MetadataIndex>,
+    tagged_span_md_cache: HashMap<(Span, &'static str), MetadataIndex>,
     file_loc_md_cache: HashMap<SourceId, MetadataIndex>,
-    storage_op_md_cache: HashMap<Purity, MetadataIndex>,
+    purity_md_cache: HashMap<Purity, MetadataIndex>,
     inline_md_cache: HashMap<Inline, MetadataIndex>,
     test_decl_index_md_cache: HashMap<DeclId<TyFunctionDecl>, MetadataIndex>,
 }
 
-#[derive(Clone, Copy)]
-pub(crate) enum StorageOperation {
-    Reads,
-    Writes,
-    ReadsWrites,
-}
-
 impl MetadataManager {
     pub(crate) fn md_to_span(
         &mut self,
@@ -46,26 +51,69 @@ impl MetadataManager {
     ) -> Option<Span> {
         Self::for_each_md_idx(context, md_idx, |md_idx| {
             self.md_span_cache.get(&md_idx).cloned().or_else(|| {
-                // Create a new span and save it in the cache.
                 md_idx
                     .get_content(context)
                     .unwrap_struct("span", 3)
                     .and_then(|fields| {
-                        let (path, src) = self.md_to_file_location(context, &fields[0])?;
-                        let start = fields[1].unwrap_integer()?;
-                        let end = fields[2].unwrap_integer()?;
-                        let source_engine = context.source_engine();
-                        let source_id = source_engine.get_source_id(&path);
-                        let span = Span::new(src, start as usize, end as usize, Some(source_id))?;
-
+                        // Create a new span and save it in the cache.
+                        let span = self.create_span_from_metadatum_fields(context, fields)?;
                         self.md_span_cache.insert(md_idx, span.clone());
-
                         Some(span)
                     })
             })
         })
     }
 
+    /// Returns the [Span] tagged with `tag` from the `md_idx`,
+    /// or `None` if such span does not exist.
+    /// If there are more spans tagged with `tag` inside of the
+    /// `md_idx`, the first one will be returned.
+    pub(crate) fn md_to_tagged_span(
+        &mut self,
+        context: &Context,
+        md_idx: Option<MetadataIndex>,
+        tag: &'static str,
+    ) -> Option<Span> {
+        Self::for_each_md_idx(context, md_idx, |md_idx| {
+            let fields = md_idx.get_content(context).unwrap_struct(tag, 3);
+
+            match fields {
+                Some(fields) => self
+                    .md_tagged_span_cache
+                    .get(&md_idx)
+                    .map(|span_and_tag| span_and_tag.0.clone())
+                    .or_else(|| {
+                        // Create a new span and save it in the cache.
+                        let span = self.create_span_from_metadatum_fields(context, fields)?;
+                        self.md_tagged_span_cache
+                            .insert(md_idx, (span.clone(), tag));
+                        Some(span)
+                    }),
+                None => None,
+            }
+        })
+    }
+
+    /// Returns the [Span] pointing to the function name in the function declaration from the `md_idx`,
+    /// or `None` if such span does not exist.
+    pub(crate) fn md_to_fn_name_span(
+        &mut self,
+        context: &Context,
+        md_idx: Option<MetadataIndex>,
+    ) -> Option<Span> {
+        self.md_to_tagged_span(context, md_idx, "fn_name_span")
+    }
+
+    /// Returns the [Span] pointing to the call path in the function call from the `md_idx`,
+    /// or `None` if such span does not exist.
+    pub(crate) fn md_to_fn_call_path_span(
+        &mut self,
+        context: &Context,
+        md_idx: Option<MetadataIndex>,
+    ) -> Option<Span> {
+        self.md_to_tagged_span(context, md_idx, "fn_call_path_span")
+    }
+
     pub(crate) fn md_to_test_decl_index(
         &mut self,
         context: &Context,
@@ -91,33 +139,37 @@ impl MetadataManager {
         })
     }
 
-    pub(crate) fn md_to_storage_op(
+    pub(crate) fn md_to_purity(
         &mut self,
         context: &Context,
         md_idx: Option<MetadataIndex>,
-    ) -> Option<StorageOperation> {
+    ) -> Purity {
+        // If the purity metadata is not available, we assume the function to
+        // be pure, because in the case of a pure function, we do not store
+        // its purity attribute, to avoid bloating the metadata.
         Self::for_each_md_idx(context, md_idx, |md_idx| {
-            self.md_storage_op_cache.get(&md_idx).copied().or_else(|| {
-                // Create a new storage op and save it in the cache.
+            self.md_purity_cache.get(&md_idx).copied().or_else(|| {
+                // Create a new purity and save it in the cache.
                 md_idx
                     .get_content(context)
-                    .unwrap_struct("storage", 1)
+                    .unwrap_struct("purity", 1)
                     .and_then(|fields| {
-                        fields[0].unwrap_string().and_then(|stor_str| {
-                            let op = match stor_str {
-                                "reads" => Some(StorageOperation::Reads),
-                                "writes" => Some(StorageOperation::Writes),
-                                "readswrites" => Some(StorageOperation::ReadsWrites),
-                                _otherwise => None,
+                        fields[0].unwrap_string().and_then(|purity_str| {
+                            let purity = match purity_str {
+                                "reads" => Some(Purity::Reads),
+                                "writes" => Some(Purity::Writes),
+                                "readswrites" => Some(Purity::ReadsWrites),
+                                _otherwise => panic!("Invalid purity metadata: {purity_str}."),
                             }?;
 
-                            self.md_storage_op_cache.insert(md_idx, op);
+                            self.md_purity_cache.insert(md_idx, purity);
 
-                            Some(op)
+                            Some(purity)
                         })
                     })
             })
         })
+        .unwrap_or(Purity::Pure)
     }
 
     /// Gets Inline information from metadata index.
@@ -189,25 +241,69 @@ impl MetadataManager {
     ) -> Option<MetadataIndex> {
         self.span_md_cache.get(span).copied().or_else(|| {
             span.source_id().and_then(|source_id| {
-                // Create new metadata.
-                let file_location_md_idx = self.file_location_to_md(context, *source_id)?;
-                let md_idx = MetadataIndex::new_struct(
-                    context,
-                    "span",
-                    vec![
-                        Metadatum::Index(file_location_md_idx),
-                        Metadatum::Integer(span.start() as u64),
-                        Metadatum::Integer(span.end() as u64),
-                    ],
-                );
-
+                let md_idx = self.create_metadata_from_span(context, source_id, span, "span")?;
                 self.span_md_cache.insert(span.clone(), md_idx);
-
                 Some(md_idx)
             })
         })
     }
 
+    /// Returns [MetadataIndex] with [Metadatum::Struct] tagged with `tag`
+    /// whose content will be the provided `span`.
+    ///
+    /// If the `span` does not have [Span::source_id], `None` is returned.
+    ///
+    /// This [Span] can later be retrieved from the [MetadataIndex] by calling
+    /// [Self::md_to_tagged_span].
+    pub(crate) fn tagged_span_to_md(
+        &mut self,
+        context: &mut Context,
+        span: &Span,
+        tag: &'static str,
+    ) -> Option<MetadataIndex> {
+        let span_and_tag = (span.clone(), tag);
+        self.tagged_span_md_cache
+            .get(&span_and_tag)
+            .copied()
+            .or_else(|| {
+                span.source_id().and_then(|source_id| {
+                    let md_idx = self.create_metadata_from_span(context, source_id, span, tag)?;
+                    self.tagged_span_md_cache.insert(span_and_tag, md_idx);
+                    Some(md_idx)
+                })
+            })
+    }
+
+    /// Returns [MetadataIndex] with [Metadatum::Struct]
+    /// whose content will be the [Span] of the `fn_name` [Ident].
+    ///
+    /// If that span does not have [Span::source_id], `None` is returned.
+    ///
+    /// This [Span] can later be retrieved from the [MetadataIndex] by calling
+    /// [Self::md_to_fn_name_span].
+    pub(crate) fn fn_name_span_to_md(
+        &mut self,
+        context: &mut Context,
+        fn_name: &Ident,
+    ) -> Option<MetadataIndex> {
+        self.tagged_span_to_md(context, &fn_name.span(), "fn_name_span")
+    }
+
+    /// Returns [MetadataIndex] with [Metadatum::Struct]
+    /// whose content will be the [Span] of the `call_path`.
+    ///
+    /// If that span does not have [Span::source_id], `None` is returned.
+    ///
+    /// This [Span] can later be retrieved from the [MetadataIndex] by calling
+    /// [Self::md_to_fn_call_path_span].
+    pub(crate) fn fn_call_path_span_to_md(
+        &mut self,
+        context: &mut Context,
+        call_path: &CallPath,
+    ) -> Option<MetadataIndex> {
+        self.tagged_span_to_md(context, &call_path.span(), "fn_call_path_span")
+    }
+
     pub(crate) fn test_decl_index_to_md(
         &mut self,
         context: &mut Context,
@@ -233,8 +329,10 @@ impl MetadataManager {
         context: &mut Context,
         purity: Purity,
     ) -> Option<MetadataIndex> {
+        // If the function is pure, we do not store the purity attribute,
+        // to avoid bloating the metadata.
         (purity != Purity::Pure).then(|| {
-            self.storage_op_md_cache
+            self.purity_md_cache
                 .get(&purity)
                 .copied()
                 .unwrap_or_else(|| {
@@ -247,11 +345,11 @@ impl MetadataManager {
                     };
                     let md_idx = MetadataIndex::new_struct(
                         context,
-                        "storage",
+                        "purity",
                         vec![Metadatum::String(field.to_owned())],
                     );
 
-                    self.storage_op_md_cache.insert(purity, md_idx);
+                    self.purity_md_cache.insert(purity, md_idx);
 
                     md_idx
                 })
@@ -314,4 +412,38 @@ impl MetadataManager {
             }
         })
     }
+
+    fn create_span_from_metadatum_fields(
+        &mut self,
+        context: &Context,
+        fields: &[Metadatum],
+    ) -> Option<Span> {
+        let (path, src) = self.md_to_file_location(context, &fields[0])?;
+        let start = fields[1].unwrap_integer()?;
+        let end = fields[2].unwrap_integer()?;
+        let source_engine = context.source_engine();
+        let source_id = source_engine.get_source_id(&path);
+        let span = Span::new(src, start as usize, end as usize, Some(source_id))?;
+        Some(span)
+    }
+
+    fn create_metadata_from_span(
+        &mut self,
+        context: &mut Context,
+        source_id: &SourceId,
+        span: &Span,
+        tag: &'static str,
+    ) -> Option<MetadataIndex> {
+        let file_location_md_idx = self.file_location_to_md(context, *source_id)?;
+        let md_idx = MetadataIndex::new_struct(
+            context,
+            tag,
+            vec![
+                Metadatum::Index(file_location_md_idx),
+                Metadatum::Integer(span.start() as u64),
+                Metadatum::Integer(span.end() as u64),
+            ],
+        );
+        Some(md_idx)
+    }
 }
diff --git a/sway-core/src/query_engine/mod.rs b/sway-core/src/query_engine/mod.rs
index 8f7e248291f..ee94d6a2f62 100644
--- a/sway-core/src/query_engine/mod.rs
+++ b/sway-core/src/query_engine/mod.rs
@@ -1,14 +1,19 @@
-use parking_lot::RwLock;
-use std::{collections::HashMap, path::PathBuf, sync::Arc, time::SystemTime};
-use sway_error::error::CompileError;
-use sway_error::warning::CompileWarning;
-use sway_types::IdentUnique;
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::{
+    collections::HashMap,
+    ops::{Deref, DerefMut},
+    path::PathBuf,
+    sync::Arc,
+    time::SystemTime,
+};
+use sway_error::{error::CompileError, warning::CompileWarning};
+use sway_types::{IdentUnique, ProgramId, SourceId, Spanned};
 
-use crate::decl_engine::{DeclId, DeclRef};
-use crate::language::ty::{TyFunctionDecl, TyFunctionSig};
-use crate::{Engines, Programs};
-
-pub type ModulePath = Arc<PathBuf>;
+use crate::{
+    decl_engine::{DeclId, DeclRef},
+    language::ty::{TyFunctionDecl, TyFunctionSig, TyModule},
+    {Engines, Programs},
+};
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct ModuleCacheKey {
@@ -26,16 +31,100 @@ impl ModuleCacheKey {
 }
 
 #[derive(Clone, Debug)]
-pub struct ModuleCacheEntry {
-    pub path: ModulePath,
-    pub modified_time: Option<SystemTime>,
+pub struct ModuleCommonInfo {
+    pub path: Arc<PathBuf>,
     pub hash: u64,
-    pub dependencies: Vec<ModulePath>,
     pub include_tests: bool,
+    pub dependencies: Vec<Arc<PathBuf>>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ParsedModuleInfo {
+    pub modified_time: Option<SystemTime>,
     pub version: Option<u64>,
 }
 
-pub type ModuleCacheMap = HashMap<ModuleCacheKey, ModuleCacheEntry>;
+#[derive(Clone, Debug)]
+pub struct TypedModuleInfo {
+    pub module: Arc<TyModule>,
+    pub version: Option<u64>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ModuleCacheEntry {
+    pub common: ModuleCommonInfo,
+    pub parsed: ParsedModuleInfo,
+    pub typed: Option<TypedModuleInfo>,
+}
+
+impl ModuleCacheEntry {
+    pub fn new(common: ModuleCommonInfo, parsed: ParsedModuleInfo) -> Self {
+        Self {
+            common,
+            parsed,
+            typed: None,
+        }
+    }
+
+    pub fn is_typed(&self) -> bool {
+        self.typed.is_some()
+    }
+
+    pub fn set_typed(&mut self, typed: TypedModuleInfo) {
+        self.typed = Some(typed);
+    }
+
+    pub fn update_common(&mut self, new_common: ModuleCommonInfo) {
+        self.common = new_common;
+    }
+
+    pub fn update_parsed(&mut self, new_parsed: ParsedModuleInfo) {
+        self.parsed = new_parsed;
+    }
+
+    pub fn update_parsed_and_common(
+        &mut self,
+        new_common: ModuleCommonInfo,
+        new_parsed: ParsedModuleInfo,
+    ) {
+        self.common = new_common;
+        self.parsed = new_parsed;
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct ModuleCacheMap(HashMap<ModuleCacheKey, ModuleCacheEntry>);
+
+impl Deref for ModuleCacheMap {
+    type Target = HashMap<ModuleCacheKey, ModuleCacheEntry>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for ModuleCacheMap {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl ModuleCacheMap {
+    pub fn update_entry(
+        &mut self,
+        key: &ModuleCacheKey,
+        new_common: ModuleCommonInfo,
+        new_parsed: ParsedModuleInfo,
+    ) {
+        if let Some(entry) = self.get_mut(key) {
+            entry.update_parsed_and_common(new_common, new_parsed);
+        } else {
+            self.insert(key.clone(), ModuleCacheEntry::new(new_common, new_parsed));
+        }
+    }
+}
+
+pub type ProgramsCacheMap = HashMap<Arc<PathBuf>, ProgramsCacheEntry>;
+pub type FunctionsCacheMap = HashMap<(IdentUnique, String), FunctionCacheEntry>;
 
 #[derive(Clone, Debug)]
 pub struct ProgramsCacheEntry {
@@ -44,35 +133,42 @@ pub struct ProgramsCacheEntry {
     pub handler_data: (Vec<CompileError>, Vec<CompileWarning>),
 }
 
-pub type ProgramsCacheMap = HashMap<Arc<PathBuf>, ProgramsCacheEntry>;
-
 #[derive(Clone, Debug)]
 pub struct FunctionCacheEntry {
     pub fn_decl: DeclRef<DeclId<TyFunctionDecl>>,
 }
 
-pub type FunctionsCacheMap = HashMap<(IdentUnique, String), FunctionCacheEntry>;
-
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default)]
 pub struct QueryEngine {
     // We want the below types wrapped in Arcs to optimize cloning from LSP.
-    parse_module_cache: Arc<RwLock<ModuleCacheMap>>,
-    programs_cache: Arc<RwLock<ProgramsCacheMap>>,
-    function_cache: Arc<RwLock<FunctionsCacheMap>>,
+    programs_cache: CowCache<ProgramsCacheMap>,
+    pub module_cache: CowCache<ModuleCacheMap>,
+    // NOTE: Any further AstNodes that are cached need to have garbage collection applied, see clear_module()
+    function_cache: CowCache<FunctionsCacheMap>,
 }
 
-impl QueryEngine {
-    pub fn get_parse_module_cache_entry(&self, path: &ModuleCacheKey) -> Option<ModuleCacheEntry> {
-        let cache = self.parse_module_cache.read();
-        cache.get(path).cloned()
+impl Clone for QueryEngine {
+    fn clone(&self) -> Self {
+        Self {
+            programs_cache: CowCache::new(self.programs_cache.read().clone()),
+            module_cache: CowCache::new(self.module_cache.read().clone()),
+            function_cache: CowCache::new(self.function_cache.read().clone()),
+        }
     }
+}
 
-    pub fn insert_parse_module_cache_entry(&self, entry: ModuleCacheEntry) {
-        let path = entry.path.clone();
-        let include_tests = entry.include_tests;
+impl QueryEngine {
+    pub fn update_or_insert_parsed_module_cache_entry(&self, entry: ModuleCacheEntry) {
+        let path = entry.common.path.clone();
+        let include_tests = entry.common.include_tests;
         let key = ModuleCacheKey::new(path, include_tests);
-        let mut cache = self.parse_module_cache.write();
-        cache.insert(key, entry);
+        let mut cache = self.module_cache.write();
+        cache.update_entry(&key, entry.common, entry.parsed);
+    }
+
+    pub fn update_typed_module_cache_entry(&self, key: &ModuleCacheKey, entry: TypedModuleInfo) {
+        let mut cache = self.module_cache.write();
+        cache.get_mut(key).unwrap().set_typed(entry);
     }
 
     pub fn get_programs_cache_entry(&self, path: &Arc<PathBuf>) -> Option<ProgramsCacheEntry> {
@@ -110,4 +206,126 @@ impl QueryEngine {
             FunctionCacheEntry { fn_decl },
         );
     }
+
+    /// Removes all data associated with the `source_id` from the function cache.
+    pub fn clear_module(&mut self, source_id: &SourceId) {
+        self.function_cache
+            .write()
+            .retain(|(ident, _), _| ident.span().source_id().map_or(true, |id| id != source_id));
+    }
+
+    /// Removes all data associated with the `program_id` from the function cache.
+    pub fn clear_program(&mut self, program_id: &ProgramId) {
+        self.function_cache.write().retain(|(ident, _), _| {
+            ident
+                .span()
+                .source_id()
+                .map_or(true, |id| id.program_id() != *program_id)
+        });
+    }
+
+    ///  Commits all changes to their respective caches.
+    pub fn commit(&self) {
+        self.programs_cache.commit();
+        self.module_cache.commit();
+        self.function_cache.commit();
+    }
+}
+
+/// Thread-safe, copy-on-write cache optimized for LSP operations.
+///
+/// Addresses key LSP challenges:
+/// 1. Concurrent read access to shared data
+/// 2. Local modifications for cancellable operations (e.g., compilation)
+/// 3. Prevents incomplete results from affecting shared state
+/// 4. Maintains consistency via explicit commit step
+///
+/// Uses `Arc<RwLock<T>>` for shared state and `RwLock<Option<T>>` for local changes.
+/// Suitable for interactive sessions with frequent file changes.
+#[derive(Debug, Default)]
+pub struct CowCache<T: Clone> {
+    inner: Arc<RwLock<T>>,
+    local: RwLock<Option<T>>,
+}
+
+impl<T: Clone> CowCache<T> {
+    /// Creates a new `CowCache` with the given initial value.
+    ///
+    /// The value is wrapped in an `Arc<RwLock<T>>` to allow shared access across threads.
+    pub fn new(value: T) -> Self {
+        Self {
+            inner: Arc::new(RwLock::new(value)),
+            local: RwLock::new(None),
+        }
+    }
+
+    /// Provides read access to the cached value.
+    ///
+    /// If a local modification exists, it returns a reference to the local copy.
+    /// Otherwise, it returns a reference to the shared state.
+    ///
+    /// This method is optimized for concurrent read access in LSP operations.
+    pub fn read(&self) -> impl Deref<Target = T> + '_ {
+        if self.local.read().is_some() {
+            ReadGuard::Local(self.local.read())
+        } else {
+            ReadGuard::Shared(self.inner.read())
+        }
+    }
+
+    /// Provides write access to a local copy of the cached value.
+    ///
+    /// In LSP, this is used for operations like compilation tasks that may be cancelled.
+    /// It allows modifications without affecting the shared state until explicitly committed.
+    pub fn write(&self) -> impl DerefMut<Target = T> + '_ {
+        let mut local = self.local.write();
+        if local.is_none() {
+            *local = Some(self.inner.read().clone());
+        }
+        WriteGuard(local)
+    }
+
+    /// Commits local modifications to the shared state.
+    ///
+    /// Called after successful completion of a compilation task.
+    /// If a task is cancelled, not calling this method effectively discards local changes.
+    pub fn commit(&self) {
+        if let Some(local) = self.local.write().take() {
+            *self.inner.write() = local;
+        }
+    }
+}
+
+/// A guard type that provides read access to either the local or shared state.
+enum ReadGuard<'a, T: Clone> {
+    Local(RwLockReadGuard<'a, Option<T>>),
+    Shared(RwLockReadGuard<'a, T>),
+}
+
+impl<'a, T: Clone> Deref for ReadGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            ReadGuard::Local(r) => r.as_ref().unwrap(),
+            ReadGuard::Shared(guard) => guard.deref(),
+        }
+    }
+}
+
+/// A guard type that provides write access to the local state.
+struct WriteGuard<'a, T: Clone>(RwLockWriteGuard<'a, Option<T>>);
+
+impl<'a, T: Clone> Deref for WriteGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref().unwrap()
+    }
+}
+
+impl<'a, T: Clone> DerefMut for WriteGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.0.as_mut().unwrap()
+    }
 }
diff --git a/sway-core/src/semantic_analysis.rs b/sway-core/src/semantic_analysis.rs
index 2988080309e..a1eb9a7f8c8 100644
--- a/sway-core/src/semantic_analysis.rs
+++ b/sway-core/src/semantic_analysis.rs
@@ -2,14 +2,17 @@
 pub mod ast_node;
 pub(crate) mod cei_pattern_analysis;
 pub(crate) mod coins_analysis;
-pub mod collection_context;
 mod module;
 pub mod namespace;
 mod node_dependencies;
 mod program;
+pub mod symbol_collection_context;
+pub mod symbol_resolve;
+pub mod symbol_resolve_context;
 mod type_check_analysis;
 pub(crate) mod type_check_context;
 mod type_check_finalization;
+pub(crate) mod type_resolve;
 pub use ast_node::*;
 pub use namespace::Namespace;
 pub(crate) use type_check_analysis::*;
diff --git a/sway-core/src/semantic_analysis/ast_node/code_block.rs b/sway-core/src/semantic_analysis/ast_node/code_block.rs
index 485fe51fa4d..330b8e4e4e9 100644
--- a/sway-core/src/semantic_analysis/ast_node/code_block.rs
+++ b/sway-core/src/semantic_analysis/ast_node/code_block.rs
@@ -5,23 +5,86 @@ use crate::language::{
 };
 
 impl ty::TyCodeBlock {
-    pub(crate) fn type_check(
+    pub(crate) fn collect(
         handler: &Handler,
-        ctx: TypeCheckContext,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
         code_block: &CodeBlock,
-    ) -> Result<Self, ErrorEmitted> {
-        ctx.scoped(|mut ctx| {
-            let evaluated_contents = code_block
+    ) -> Result<(), ErrorEmitted> {
+        let _ = ctx.scoped(engines, code_block.whole_block_span.clone(), |scoped_ctx| {
+            let _ = code_block
                 .contents
                 .iter()
-                .filter_map(|node| ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok())
-                .collect::<Vec<ty::TyAstNode>>();
+                .map(|node| ty::TyAstNode::collect(handler, engines, scoped_ctx, node))
+                .filter_map(|res| res.ok())
+                .collect::<Vec<_>>();
+            Ok(())
+        });
+        Ok(())
+    }
+
+    pub(crate) fn type_check(
+        handler: &Handler,
+        mut ctx: TypeCheckContext,
+        code_block: &CodeBlock,
+        is_root: bool,
+    ) -> Result<Self, ErrorEmitted> {
+        if !is_root {
+            let code_block_result =
+                ctx.by_ref()
+                    .scoped(handler, Some(code_block.span()), |mut ctx| {
+                        let evaluated_contents = code_block
+                            .contents
+                            .iter()
+                            .filter_map(|node| {
+                                ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok()
+                            })
+                            .collect::<Vec<ty::TyAstNode>>();
+                        Ok(ty::TyCodeBlock {
+                            contents: evaluated_contents,
+                            whole_block_span: code_block.whole_block_span.clone(),
+                        })
+                    })?;
+
+            return Ok(code_block_result);
+        }
+
+        ctx.engines.te().clear_unifications();
+        ctx.namespace()
+            .module(ctx.engines)
+            .current_lexical_scope()
+            .items
+            .clear_symbols_unique_while_collecting_unifications();
 
-            Ok(ty::TyCodeBlock {
-                contents: evaluated_contents,
-                whole_block_span: code_block.whole_block_span.clone(),
+        // We are typechecking the code block AST nodes twice.
+        // The first pass does all the unifications to the variables types.
+        // In the second pass we use the previous_namespace on variable declaration to unify directly with the result of the first pass.
+        // This is required to fix the test case numeric_type_propagation and issue #6371
+        ctx.by_ref()
+            .with_collecting_unifications()
+            .with_code_block_first_pass(true)
+            .scoped(handler, Some(code_block.span()), |mut ctx| {
+                code_block.contents.iter().for_each(|node| {
+                    ty::TyAstNode::type_check(&Handler::default(), ctx.by_ref(), node).ok();
+                });
+                Ok(())
+            })?;
+
+        ctx.engines.te().reapply_unifications(ctx.engines());
+
+        ctx.by_ref()
+            .scoped(handler, Some(code_block.span()), |mut ctx| {
+                let evaluated_contents = code_block
+                    .contents
+                    .iter()
+                    .filter_map(|node| ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok())
+                    .collect::<Vec<ty::TyAstNode>>();
+
+                Ok(ty::TyCodeBlock {
+                    contents: evaluated_contents,
+                    whole_block_span: code_block.whole_block_span.clone(),
+                })
             })
-        })
     }
 
     pub fn compute_return_type_and_span(
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/abi.rs b/sway-core/src/semantic_analysis/ast_node/declaration/abi.rs
index f6c1cc1e0d1..bb0bc9e2fb8 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/abi.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/abi.rs
@@ -4,14 +4,17 @@ use sway_error::error::CompileError;
 use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
-    decl_engine::{DeclEngineInsert, DeclEngineInsertArc, DeclId},
-    language::ty::TyAbiDecl,
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineGetParsedDeclId, DeclEngineInsert, DeclEngineInsertArc,
+        DeclId,
+    },
+    language::ty::{TyAbiDecl, TyFunctionDecl},
     namespace::{IsExtendingExistingImpl, IsImplSelf, TryInsertingTraitImplOnFailure},
     semantic_analysis::{
-        TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckFinalization,
-        TypeCheckFinalizationContext,
+        symbol_collection_context::SymbolCollectionContext, TypeCheckAnalysis,
+        TypeCheckAnalysisContext, TypeCheckFinalization, TypeCheckFinalizationContext,
     },
-    TypeParameter,
+    Engines, TypeParameter,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
 
@@ -29,6 +32,33 @@ use crate::{
 };
 
 impl ty::TyAbiDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<AbiDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let abi_decl = engines.pe().get_abi(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            abi_decl.name.clone(),
+            Declaration::AbiDeclaration(*decl_id),
+        )?;
+
+        let _ = ctx.scoped(engines, abi_decl.span.clone(), |scoped_ctx| {
+            abi_decl.interface_surface.iter().for_each(|item| {
+                let _ = TyTraitItem::collect(handler, engines, scoped_ctx, item);
+            });
+
+            abi_decl.methods.iter().for_each(|decl_id| {
+                let _ = TyFunctionDecl::collect(handler, engines, scoped_ctx, decl_id);
+            });
+            Ok(())
+        });
+        Ok(())
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
         ctx: TypeCheckContext,
@@ -55,7 +85,7 @@ impl ty::TyAbiDecl {
         // A temporary namespace for checking within this scope.
         ctx.with_abi_mode(AbiMode::ImplAbiFn(name.clone(), None))
             .with_self_type(Some(self_type_id))
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(span.clone()), |mut ctx| {
                 // Insert the "self" type param into the namespace.
                 self_type_param.insert_self_type_into_namespace(handler, ctx.by_ref());
 
@@ -119,7 +149,7 @@ impl ty::TyAbiDecl {
                                 }
                             }
                             new_interface_surface.push(ty::TyTraitInterfaceItem::TraitFn(
-                                ctx.engines.de().insert(method.clone()),
+                                ctx.engines.de().insert(method.clone(), Some(&decl_id)),
                             ));
                             method.name.clone()
                         }
@@ -127,7 +157,8 @@ impl ty::TyAbiDecl {
                             let const_decl = engines.pe().get_constant(&decl_id).as_ref().clone();
                             let const_decl =
                                 ty::TyConstantDecl::type_check(handler, ctx.by_ref(), const_decl)?;
-                            let decl_ref = ctx.engines.de().insert(const_decl.clone());
+                            let decl_ref =
+                                ctx.engines.de().insert(const_decl.clone(), Some(&decl_id));
                             new_interface_surface
                                 .push(ty::TyTraitInterfaceItem::Constant(decl_ref.clone()));
 
@@ -150,7 +181,8 @@ impl ty::TyAbiDecl {
 
                             let type_decl =
                                 ty::TyTraitType::type_check(handler, ctx.by_ref(), type_decl)?;
-                            let decl_ref = ctx.engines().de().insert(type_decl.clone());
+                            let decl_ref =
+                                ctx.engines().de().insert(type_decl.clone(), Some(&decl_id));
                             new_interface_surface
                                 .push(ty::TyTraitInterfaceItem::Type(decl_ref.clone()));
 
@@ -197,7 +229,9 @@ impl ty::TyAbiDecl {
                             span: method.name.span(),
                         });
                     }
-                    new_items.push(TyTraitItem::Fn(ctx.engines.de().insert(method)));
+                    new_items.push(TyTraitItem::Fn(
+                        ctx.engines.de().insert(method, Some(&method_id)),
+                    ));
                 }
 
                 // Compared to regular traits, we do not insert recursively methods of ABI supertraits
@@ -288,12 +322,14 @@ impl ty::TyAbiDecl {
                             }
                         }
                         all_items.push(TyImplItem::Fn(
-                            ctx.engines
-                                .de()
-                                .insert(method.to_dummy_func(
-                                    AbiMode::ImplAbiFn(self.name.clone(), Some(self_decl_id)),
-                                    Some(type_id),
-                                ))
+                            decl_engine
+                                .insert(
+                                    method.to_dummy_func(
+                                        AbiMode::ImplAbiFn(self.name.clone(), Some(self_decl_id)),
+                                        Some(type_id),
+                                    ),
+                                    None,
+                                )
                                 .with_parent(ctx.engines.de(), (*decl_ref.id()).into()),
                         ));
                     }
@@ -349,21 +385,27 @@ impl ty::TyAbiDecl {
                             }
                         }
                         all_items.push(TyImplItem::Fn(
-                            ctx.engines
-                                .de()
-                                .insert_arc(method)
+                            decl_engine
+                                .insert_arc(
+                                    method,
+                                    decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                                )
                                 .with_parent(ctx.engines.de(), (*decl_ref.id()).into()),
                         ));
                     }
                     ty::TyTraitItem::Constant(decl_ref) => {
                         let const_decl = decl_engine.get_constant(decl_ref);
-                        all_items.push(TyImplItem::Constant(
-                            ctx.engines.de().insert_arc(const_decl),
-                        ));
+                        all_items.push(TyImplItem::Constant(decl_engine.insert_arc(
+                            const_decl,
+                            decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                        )));
                     }
                     ty::TyTraitItem::Type(decl_ref) => {
                         let type_decl = decl_engine.get_type(decl_ref);
-                        all_items.push(TyImplItem::Type(ctx.engines.de().insert_arc(type_decl)));
+                        all_items.push(TyImplItem::Type(decl_engine.insert_arc(
+                            type_decl,
+                            decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                        )));
                     }
                 }
             }
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl.rs b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl.rs
index 40d9a925a21..55ef6a25e79 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl.rs
@@ -1,6 +1,6 @@
 use crate::{
     asm_generation::fuel::compiler_constants::MISMATCHED_SELECTOR_REVERT_CODE,
-    decl_engine::{DeclEngineGet, DeclId, DeclRef},
+    decl_engine::{DeclEngineGet, DeclId},
     engine_threading::SpannedWithEngines,
     language::{
         parsed::{self, AstNodeContent, Declaration, FunctionDeclarationKind},
@@ -38,7 +38,7 @@ where
         T: Parse,
     {
         // Uncomment this to see what is being generated
-        // println!("{}", input);
+        //println!("{}", input);
 
         let handler = <_>::default();
         let source_id =
@@ -221,7 +221,7 @@ where
                     },
                     _ => {
                         let variant_type_name = Self::generate_type(engines, x.type_argument.type_id)?;
-                        format!("{tag_value} => {enum_name}::{variant_name}(buffer.decode::<{variant_type}>()), \n", 
+                        format!("{tag_value} => {enum_name}::{variant_name}(buffer.decode::<{variant_type}>()), \n",
                             tag_value = x.tag,
                             enum_name = enum_name,
                             variant_name = name,
@@ -324,7 +324,18 @@ where
         assert!(!handler.has_warnings(), "{:?}", handler);
 
         let ctx = self.ctx.by_ref();
-        let r = ctx.scoped_and_namespace(|ctx| {
+        let _r = TyDecl::collect(
+            &handler,
+            engines,
+            ctx.collection_ctx,
+            Declaration::FunctionDeclaration(decl),
+        );
+        if handler.has_errors() {
+            return Err(handler);
+        }
+
+        let ctx = self.ctx.by_ref();
+        let r = ctx.scoped_and_namespace(&handler, None, |ctx| {
             TyDecl::type_check(
                 &handler,
                 ctx,
@@ -333,7 +344,7 @@ where
         });
 
         // Uncomment this to understand why an entry function was not generated
-        // println!("{:#?}", handler);
+        //println!("{:#?}", handler);
 
         let (decl, namespace) = r.map_err(|_| handler.clone())?;
 
@@ -368,19 +379,29 @@ where
         .unwrap();
 
         let decl = match nodes[0].content {
-            AstNodeContent::Declaration(Declaration::ImplTrait(f)) => f,
+            AstNodeContent::Declaration(Declaration::ImplSelfOrTrait(f)) => f,
             _ => unreachable!("unexpected item"),
         };
 
         assert!(!handler.has_errors(), "{:?}", handler);
 
         let ctx = self.ctx.by_ref();
-        let r = ctx.scoped_and_namespace(|ctx| {
-            TyDecl::type_check(&handler, ctx, Declaration::ImplTrait(decl))
+        let _r = TyDecl::collect(
+            &handler,
+            engines,
+            ctx.collection_ctx,
+            Declaration::ImplSelfOrTrait(decl),
+        );
+        if handler.has_errors() {
+            return Err(handler);
+        }
+
+        let r = ctx.scoped_and_namespace(&handler, None, |ctx| {
+            TyDecl::type_check(&handler, ctx, Declaration::ImplSelfOrTrait(decl))
         });
 
         // Uncomment this to understand why auto impl failed for a type.
-        // println!("{:#?}", handler);
+        //println!("{:#?}", handler);
 
         let (decl, namespace) = r.map_err(|_| handler.clone())?;
 
@@ -401,13 +422,12 @@ where
         engines: &Engines,
         decl: &TyDecl,
     ) -> Option<(Option<TyAstNode>, Option<TyAstNode>)> {
-        if matches!(self.ctx.namespace.root().module.read(engines, |m| m.name.clone()).as_ref(), Some(x) if x.as_str() == "core")
-        {
+        if self.ctx.namespace.root().module.name().as_str() == "core" {
             return Some((None, None));
         }
 
-        let implementing_for_decl_ref = decl.to_struct_ref(&Handler::default(), engines).unwrap();
-        let struct_decl = self.ctx.engines().de().get(implementing_for_decl_ref.id());
+        let implementing_for_decl_id = decl.to_struct_decl(&Handler::default(), engines).unwrap();
+        let struct_decl = self.ctx.engines().de().get(&implementing_for_decl_id);
 
         let program_id = struct_decl.span().source_id().map(|sid| sid.program_id());
 
@@ -437,13 +457,12 @@ where
         engines: &Engines,
         decl: &TyDecl,
     ) -> Option<(Option<TyAstNode>, Option<TyAstNode>)> {
-        if matches!(self.ctx.namespace.root().module.read(engines, |m| m.name.clone()).as_ref(), Some(x) if x.as_str() == "core")
-        {
+        if self.ctx.namespace.root().module.name().as_str() == "core" {
             return Some((None, None));
         }
 
-        let enum_decl_ref = decl.to_enum_ref(&Handler::default(), engines).unwrap();
-        let enum_decl = self.ctx.engines().de().get(enum_decl_ref.id());
+        let enum_decl_id = decl.to_enum_id(&Handler::default(), engines).unwrap();
+        let enum_decl = self.ctx.engines().de().get(&enum_decl_id);
 
         let program_id = enum_decl.span().source_id().map(|sid| sid.program_id());
 
@@ -510,8 +529,8 @@ where
                 format!("({},)", field_strs.join(", "))
             }
             TypeInfo::B256 => "b256".into(),
-            TypeInfo::Enum(decl_ref) => {
-                let decl = engines.de().get(decl_ref.id());
+            TypeInfo::Enum(decl_id) => {
+                let decl = engines.de().get_enum(decl_id);
 
                 let type_parameters = decl
                     .type_parameters
@@ -528,8 +547,8 @@ where
 
                 format!("{}{type_parameters}", decl.call_path.suffix.as_str())
             }
-            TypeInfo::Struct(decl_ref) => {
-                let decl = engines.de().get(decl_ref.id());
+            TypeInfo::Struct(decl_id) => {
+                let decl = engines.de().get(decl_id);
 
                 let type_parameters = decl
                     .type_parameters
@@ -553,6 +572,12 @@ where
                     count.val()
                 )
             }
+            TypeInfo::Slice(elem_ty) => {
+                format!(
+                    "__slice[{}]",
+                    Self::generate_type(engines, elem_ty.type_id)?
+                )
+            }
             TypeInfo::RawUntypedPtr => "raw_ptr".into(),
             TypeInfo::RawUntypedSlice => "raw_slice".into(),
             TypeInfo::Alias { name, .. } => name.to_string(),
@@ -566,7 +591,7 @@ where
         &mut self,
         engines: &Engines,
         program_id: Option<ProgramId>,
-        contract_fns: &[DeclRef<DeclId<TyFunctionDecl>>],
+        contract_fns: &[DeclId<TyFunctionDecl>],
         fallback_fn: Option<DeclId<TyFunctionDecl>>,
         handler: &Handler,
     ) -> Result<TyAstNode, ErrorEmitted> {
@@ -576,7 +601,7 @@ where
         let mut writes = false;
 
         for r in contract_fns {
-            let decl = engines.de().get(r.id());
+            let decl = engines.de().get(r);
 
             match decl.purity {
                 Purity::Pure => {}
@@ -625,18 +650,29 @@ where
 
             let method_name = decl.name.as_str();
 
+            code.push_str(&format!("if _method_name == \"{method_name}\" {{\n"));
+
             if args_types == "()" {
-                code.push_str(&format!("if _method_name == \"{method_name}\" {{
-                    let result_{method_name}: raw_slice = encode::<{return_type}>(__contract_entry_{method_name}());
-                    __contract_ret(result_{method_name}.ptr(), result_{method_name}.len::<u8>());
-                }}\n"));
+                code.push_str(&format!(
+                    "let _result = __contract_entry_{method_name}();\n"
+                ));
             } else {
-                code.push_str(&format!("if _method_name == \"{method_name}\" {{
-                    let args: {args_types} = decode_second_param::<{args_types}>();
-                    let result_{method_name}: raw_slice = encode::<{return_type}>(__contract_entry_{method_name}({expanded_args}));
-                    __contract_ret(result_{method_name}.ptr(), result_{method_name}.len::<u8>());
-                }}\n"));
+                code.push_str(&format!(
+                    "let args: {args_types} = _buffer.decode::<{args_types}>();
+                    let _result: {return_type} = __contract_entry_{method_name}({expanded_args});\n"
+                ));
             }
+
+            if return_type == "()" {
+                code.push_str("__contract_ret(asm() { zero: raw_ptr }, 0);");
+            } else {
+                code.push_str(&format!(
+                    "let _result: raw_slice = encode::<{return_type}>(_result);
+                    __contract_ret(_result.ptr(), _result.len::<u8>());"
+                ));
+            }
+
+            code.push_str("\n}\n");
         }
 
         let fallback = if let Some(fallback_fn) = fallback_fn {
@@ -664,16 +700,16 @@ where
             format!("__revert({});", MISMATCHED_SELECTOR_REVERT_CODE)
         };
 
-        let att: String = match (reads, writes) {
+        let att = match (reads, writes) {
             (true, true) => "#[storage(read, write)]",
             (true, false) => "#[storage(read)]",
             (false, true) => "#[storage(write)]",
             (false, false) => "",
-        }
-        .into();
+        };
 
         let code = format!(
             "{att} pub fn __entry() {{
+            let mut _buffer = BufferReader::from_second_parameter();
             let _method_name = decode_first_param::<str>();
             {code}
             {fallback}
@@ -837,7 +873,7 @@ where
         let code = if args_types == "()" {
             format!(
                 "pub fn __entry() -> raw_slice {{
-                let result: {return_type} = main(); 
+                let result: {return_type} = main();
                 encode::<{return_type}>(result)
             }}"
             )
@@ -845,7 +881,7 @@ where
             format!(
                 "pub fn __entry() -> raw_slice {{
                 let args: {args_types} = decode_script_data::<{args_types}>();
-                let result: {return_type} = main({expanded_args}); 
+                let result: {return_type} = main({expanded_args});
                 encode::<{return_type}>(result)
             }}"
             )
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs b/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs
index 7056a0a2988..6c9f5e7f404 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs
@@ -1,23 +1,47 @@
 use std::collections::VecDeque;
 
 use sway_error::{
+    error::CompileError,
     handler::{ErrorEmitted, Handler},
     warning::{CompileWarning, Warning},
 };
 use sway_types::{style::is_screaming_snake_case, Spanned};
+use symbol_collection_context::SymbolCollectionContext;
 
 use crate::{
-    decl_engine::{DeclEngineInsert, ReplaceDecls},
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineGetParsedDeclId, DeclEngineInsert, ReplaceDecls,
+    },
     language::{
         parsed::*,
-        ty::{self, TyConfigurableDecl},
+        ty::{self, TyConfigurableDecl, TyExpression},
         CallPath,
     },
-    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
-    SubstTypes, TypeArgument, TypeBinding, TypeCheckTypeBinding, TypeInfo,
+    semantic_analysis::*,
+    EnforceTypeArguments, Engines, SubstTypes, TypeArgument, TypeBinding, TypeCheckTypeBinding,
+    TypeInfo,
 };
 
 impl ty::TyConfigurableDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<ConfigurableDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let configurable_decl = engines.pe().get_configurable(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            configurable_decl.name.clone(),
+            Declaration::ConfigurableDeclaration(*decl_id),
+        )?;
+        if let Some(value) = &configurable_decl.value {
+            TyExpression::collect(handler, engines, ctx, value)?;
+        }
+        Ok(())
+    }
+
     pub fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,
@@ -33,6 +57,7 @@ impl ty::TyConfigurableDecl {
             value,
             attributes,
             visibility,
+            block_keyword_span,
         } = decl;
 
         type_ascription.type_id = ctx
@@ -46,7 +71,7 @@ impl ty::TyConfigurableDecl {
             .unwrap_or_else(|err| type_engine.insert(engines, TypeInfo::ErrorRecovery(err), None));
 
         // this subst is required to replace associated types, namely TypeInfo::TraitType.
-        type_ascription.type_id.subst(&ctx.type_subst(), engines);
+        type_ascription.type_id.subst(&ctx.subst_ctx());
 
         if !is_screaming_snake_case(name.as_str()) {
             handler.emit_warn(CompileWarning {
@@ -84,28 +109,46 @@ impl ty::TyConfigurableDecl {
                     .insert(engines, TypeInfo::RawUntypedSlice, None),
             );
 
-            let (decode_fn_ref, _, _): (crate::decl_engine::DeclRefFunction, _, _) =
-                crate::TypeBinding::type_check(
-                    &mut TypeBinding::<CallPath> {
-                        inner: CallPath {
-                            prefixes: vec![],
-                            suffix: sway_types::Ident::new_no_span("abi_decode_in_place".into()),
-                            is_absolute: false,
-                        },
-                        type_arguments: crate::TypeArgs::Regular(vec![TypeArgument {
-                            type_id: type_ascription.type_id,
-                            initial_type_id: type_ascription.type_id,
-                            span: sway_types::Span::dummy(),
-                            call_path_tree: None,
-                        }]),
-                        span: sway_types::Span::dummy(),
+            let value_span = value
+                .as_ref()
+                .map(|x| x.span.clone())
+                .unwrap_or_else(|| span.clone());
+            let abi_decode_in_place_handler = Handler::default();
+            let r = crate::TypeBinding::type_check(
+                &mut TypeBinding::<CallPath> {
+                    inner: CallPath {
+                        prefixes: vec![],
+                        suffix: sway_types::Ident::new_with_override(
+                            "abi_decode_in_place".into(),
+                            value_span.clone(),
+                        ),
+                        is_absolute: false,
                     },
-                    handler,
-                    ctx.by_ref(),
-                )
-                .unwrap();
+                    type_arguments: crate::TypeArgs::Regular(vec![TypeArgument {
+                        type_id: type_ascription.type_id,
+                        initial_type_id: type_ascription.type_id,
+                        span: sway_types::Span::dummy(),
+                        call_path_tree: None,
+                    }]),
+                    span: value_span.clone(),
+                },
+                &abi_decode_in_place_handler,
+                ctx.by_ref(),
+            );
 
-            let mut decode_fn_decl = (*engines.de().get_function(&decode_fn_ref)).clone();
+            // Map expected errors to more understandable ones
+            handler.map_and_emit_errors_from(abi_decode_in_place_handler, |e| match e {
+                CompileError::SymbolNotFound { .. } => {
+                    Some(CompileError::ConfigurableMissingAbiDecodeInPlace {
+                        span: block_keyword_span.clone(),
+                    })
+                }
+                e => Some(e),
+            })?;
+            let (decode_fn_ref, _, _): (crate::decl_engine::DeclRefFunction, _, _) = r?;
+
+            let decode_fn_id = *decode_fn_ref.id();
+            let mut decode_fn_decl = (*engines.de().get_function(&decode_fn_id)).clone();
             let decl_mapping = crate::TypeParameter::gather_decl_mapping_from_trait_constraints(
                 handler,
                 ctx.by_ref(),
@@ -116,8 +159,11 @@ impl ty::TyConfigurableDecl {
             decode_fn_decl.replace_decls(&decl_mapping, handler, &mut ctx)?;
             let decode_fn_ref = engines
                 .de()
-                .insert(decode_fn_decl)
-                .with_parent(engines.de(), (*decode_fn_ref.id()).into());
+                .insert(
+                    decode_fn_decl,
+                    engines.de().get_parsed_decl_id(&decode_fn_id).as_ref(),
+                )
+                .with_parent(engines.de(), decode_fn_id.into());
 
             (value, Some(decode_fn_ref))
         } else {
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/constant.rs b/sway-core/src/semantic_analysis/ast_node/declaration/constant.rs
index b574753b6d7..e5cca67ecde 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/constant.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/constant.rs
@@ -3,18 +3,39 @@ use sway_error::{
     warning::{CompileWarning, Warning},
 };
 use sway_types::{style::is_screaming_snake_case, Spanned};
+use symbol_collection_context::SymbolCollectionContext;
 
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     language::{
         parsed::{self, *},
-        ty::{self, TyConstantDecl},
+        ty::{self, TyConstantDecl, TyExpression},
         CallPath,
     },
-    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
-    Engines, SubstTypes, TypeInfo,
+    semantic_analysis::*,
+    EnforceTypeArguments, Engines, SubstTypes, TypeInfo,
 };
 
 impl ty::TyConstantDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<ConstantDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let constant_decl = engines.pe().get_constant(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            constant_decl.name.clone(),
+            Declaration::ConstantDeclaration(*decl_id),
+        )?;
+        if let Some(value) = &constant_decl.value {
+            TyExpression::collect(handler, engines, ctx, value)?;
+        }
+        Ok(())
+    }
+
     pub fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,
@@ -28,7 +49,6 @@ impl ty::TyConstantDecl {
             span,
             mut type_ascription,
             value,
-            is_configurable,
             attributes,
             visibility,
         } = decl;
@@ -44,7 +64,7 @@ impl ty::TyConstantDecl {
             .unwrap_or_else(|err| type_engine.insert(engines, TypeInfo::ErrorRecovery(err), None));
 
         // this subst is required to replace associated types, namely TypeInfo::TraitType.
-        type_ascription.type_id.subst(&ctx.type_subst(), engines);
+        type_ascription.type_id.subst(&ctx.subst_ctx());
 
         if !is_screaming_snake_case(name.as_str()) {
             handler.emit_warn(CompileWarning {
@@ -53,48 +73,28 @@ impl ty::TyConstantDecl {
             })
         }
 
-        // Configurables will be encoded and must be type_checked into "slice"
-        let (value, return_type) = if is_configurable && ctx.experimental.new_encoding {
-            let mut ctx = ctx
-                .by_ref()
-                .with_type_annotation(type_engine.insert(engines, TypeInfo::RawUntypedSlice, None))
-                .with_help_text("Configurables must evaluate to slices.");
-
-            let value = value.map(|value| {
-                ty::TyExpression::type_check(handler, ctx.by_ref(), &value)
-                    .unwrap_or_else(|err| ty::TyExpression::error(err, name.span(), engines))
-            });
-
-            (
-                value,
-                type_engine.insert(engines, TypeInfo::RawUntypedSlice, None),
-            )
-        } else {
-            let mut ctx = ctx
-                .by_ref()
-                .with_type_annotation(type_ascription.type_id)
-                .with_help_text(
-                    "This declaration's type annotation does not match up with the assigned \
-            expression's type.",
-                );
-
-            let value = value.map(|value| {
-                ty::TyExpression::type_check(handler, ctx.by_ref(), &value)
-                    .unwrap_or_else(|err| ty::TyExpression::error(err, name.span(), engines))
-            });
-            // Integers are special in the sense that we can't only rely on the type of `expression`
-            // to get the type of the variable. The type of the variable *has* to follow
-            // `type_ascription` if `type_ascription` is a concrete integer type that does not
-            // conflict with the type of `expression` (i.e. passes the type checking above).
-            let return_type = match &*type_engine.get(type_ascription.type_id) {
-                TypeInfo::UnsignedInteger(_) => type_ascription.type_id,
-                _ => match &value {
-                    Some(value) => value.return_type,
-                    None => type_ascription.type_id,
-                },
-            };
-
-            (value, return_type)
+        let mut ctx = ctx
+            .by_ref()
+            .with_type_annotation(type_ascription.type_id)
+            .with_help_text(
+                "This declaration's type annotation does not match up with the assigned \
+        expression's type.",
+            );
+
+        let value = value.map(|value| {
+            ty::TyExpression::type_check(handler, ctx.by_ref(), &value)
+                .unwrap_or_else(|err| ty::TyExpression::error(err, name.span(), engines))
+        });
+        // Integers are special in the sense that we can't only rely on the type of `expression`
+        // to get the type of the variable. The type of the variable *has* to follow
+        // `type_ascription` if `type_ascription` is a concrete integer type that does not
+        // conflict with the type of `expression` (i.e. passes the type checking above).
+        let return_type = match &*type_engine.get(type_ascription.type_id) {
+            TypeInfo::UnsignedInteger(_) => type_ascription.type_id,
+            _ => match &value {
+                Some(value) => value.return_type,
+                None => type_ascription.type_id,
+            },
         };
 
         let mut call_path: CallPath = name.into();
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs b/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs
index 10c4bb9894c..663891261bd 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs
@@ -1,18 +1,22 @@
 use sway_error::handler::{ErrorEmitted, Handler};
-use sway_types::{BaseIdent, Ident, Named, Spanned};
+use sway_types::{Ident, Named, Spanned};
 
 use crate::{
     decl_engine::{DeclEngineGet, DeclEngineInsert, DeclRef, ReplaceFunctionImplementingType},
     language::{
         parsed::{self, StorageEntry},
-        ty::{self, FunctionDecl, TyDecl, TyStorageField},
+        ty::{
+            self, FunctionDecl, TyAbiDecl, TyConfigurableDecl, TyConstantDecl, TyDecl, TyEnumDecl,
+            TyFunctionDecl, TyImplSelfOrTrait, TyStorageDecl, TyStorageField, TyStructDecl,
+            TyTraitDecl, TyTraitFn, TyTraitType, TyTypeAliasDecl, TyVariableDecl,
+        },
         CallPath,
     },
     namespace::{IsExtendingExistingImpl, IsImplSelf},
     semantic_analysis::{
-        collection_context::SymbolCollectionContext, type_check_context::EnforceTypeArguments,
-        ConstShadowingMode, GenericShadowingMode, TypeCheckAnalysis, TypeCheckAnalysisContext,
-        TypeCheckContext, TypeCheckFinalization, TypeCheckFinalizationContext,
+        symbol_collection_context::SymbolCollectionContext, ConstShadowingMode,
+        GenericShadowingMode, TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckContext,
+        TypeCheckFinalization, TypeCheckFinalizationContext,
     },
     type_system::*,
     Engines,
@@ -27,67 +31,44 @@ impl TyDecl {
     ) -> Result<(), ErrorEmitted> {
         match &decl {
             parsed::Declaration::VariableDeclaration(decl_id) => {
-                let var_decl = engines.pe().get_variable(decl_id);
-                ctx.insert_parsed_symbol(handler, engines, var_decl.name.clone(), decl)?;
+                TyVariableDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::ConstantDeclaration(decl_id) => {
-                let const_decl = engines.pe().get_constant(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, const_decl.name.clone(), decl)?;
+                TyConstantDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::ConfigurableDeclaration(decl_id) => {
-                let config_decl = engines.pe().get_configurable(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, config_decl.name.clone(), decl)?;
+                TyConfigurableDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::TraitTypeDeclaration(decl_id) => {
-                let trait_type_decl = engines.pe().get_trait_type(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, trait_type_decl.name.clone(), decl)?;
+                TyTraitType::collect(handler, engines, ctx, decl_id)?
+            }
+            parsed::Declaration::TraitFnDeclaration(decl_id) => {
+                TyTraitFn::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::EnumDeclaration(decl_id) => {
-                let enum_decl = engines.pe().get_enum(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, enum_decl.name.clone(), decl)?;
+                TyEnumDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::EnumVariantDeclaration(_decl) => {}
             parsed::Declaration::FunctionDeclaration(decl_id) => {
-                let fn_decl = engines.pe().get_function(decl_id);
-                let _ = ctx.insert_parsed_symbol(handler, engines, fn_decl.name.clone(), decl);
+                TyFunctionDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::TraitDeclaration(decl_id) => {
-                let trait_decl = engines.pe().get_trait(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, trait_decl.name.clone(), decl)?;
-            }
-            parsed::Declaration::ImplTrait(decl_id) => {
-                let impl_trait = engines.pe().get_impl_trait(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(
-                    handler,
-                    engines,
-                    impl_trait.trait_name.suffix.clone(),
-                    decl,
-                )?;
+                TyTraitDecl::collect(handler, engines, ctx, decl_id)?
             }
-            parsed::Declaration::ImplSelf(decl_id) => {
-                let impl_self = engines.pe().get_impl_self(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(
-                    handler,
-                    engines,
-                    BaseIdent::new(impl_self.implementing_for.span),
-                    decl,
-                )?;
+            parsed::Declaration::ImplSelfOrTrait(decl_id) => {
+                TyImplSelfOrTrait::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::StructDeclaration(decl_id) => {
-                let struct_decl = engines.pe().get_struct(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, struct_decl.name.clone(), decl)?;
+                TyStructDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::AbiDeclaration(decl_id) => {
-                let abi_decl = engines.pe().get_abi(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, abi_decl.name.clone(), decl)?;
+                TyAbiDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::StorageDeclaration(decl_id) => {
-                let _storage_decl = engines.pe().get_storage(decl_id).as_ref().clone();
-                //ctx.insert_parsed_symbol(handler, storage_decl.name.clone(), decl)?;
+                TyStorageDecl::collect(handler, engines, ctx, decl_id)?
             }
             parsed::Declaration::TypeAliasDeclaration(decl_id) => {
-                let type_alias_decl = engines.pe().get_type_alias(decl_id).as_ref().clone();
-                ctx.insert_parsed_symbol(handler, engines, type_alias_decl.name, decl.clone())?;
+                TyTypeAliasDecl::collect(handler, engines, ctx, decl_id)?
             }
         };
 
@@ -105,65 +86,15 @@ impl TyDecl {
 
         let decl = match decl {
             parsed::Declaration::VariableDeclaration(decl_id) => {
-                let var_decl = engines.pe().get_variable(&decl_id);
-                let mut type_ascription = var_decl.type_ascription.clone();
-
-                type_ascription.type_id = ctx
-                    .resolve_type(
-                        handler,
-                        type_ascription.type_id,
-                        &type_ascription.span,
-                        EnforceTypeArguments::Yes,
-                        None,
-                    )
-                    .unwrap_or_else(|err| {
-                        type_engine.insert(engines, TypeInfo::ErrorRecovery(err), None)
-                    });
-                let mut ctx = ctx
-                    .with_type_annotation(type_ascription.type_id)
-                    .with_help_text(
-                        "Variable declaration's type annotation does not match up \
-                        with the assigned expression's type.",
-                    );
-                let result = ty::TyExpression::type_check(handler, ctx.by_ref(), &var_decl.body);
-                let body = result.unwrap_or_else(|err| {
-                    ty::TyExpression::error(err, var_decl.name.span(), engines)
-                });
-
-                // TODO: Integers shouldn't be anything special. RHS expressions should be written in
-                //       a way to always use the context provided from the LHS, and if the LHS is
-                //       an integer, RHS should properly unify or type check should fail.
-                //       Remove this special case as a part of the initiative of improving type inference.
-                // Integers are special in the sense that we can't only rely on the type of `body`
-                // to get the type of the variable. The type of the variable *has* to follow
-                // `type_ascription` if `type_ascription` is a concrete integer type that does not
-                // conflict with the type of `body` (i.e. passes the type checking above).
-                let return_type = match &*type_engine.get(type_ascription.type_id) {
-                    TypeInfo::UnsignedInteger(_) => type_ascription.type_id,
-                    _ => match &*type_engine.get(body.return_type) {
-                        // If RHS type check ends up in an error we want to use the
-                        // provided type ascription as the variable type. E.g.:
-                        //   let v: Struct<u8> = Struct<u64> { x: 0 }; // `v` should be "Struct<u8>".
-                        //   let v: ExistingType = non_existing_identifier; // `v` should be "ExistingType".
-                        //   let v = <some error>; // `v` will remain "{unknown}".
-                        // TODO: Refine and improve this further. E.g.,
-                        //   let v: Struct { /* MISSING FIELDS */ }; // Despite the error, `v` should be of type "Struct".
-                        TypeInfo::ErrorRecovery(_) => type_ascription.type_id,
-                        _ => body.return_type,
-                    },
+                let decl = engines.pe().get_variable(&decl_id).as_ref().clone();
+                let name = decl.name.clone();
+                let span = decl.name.span();
+                let var_decl = match ty::TyVariableDecl::type_check(handler, ctx.by_ref(), decl) {
+                    Ok(res) => res,
+                    Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
                 };
-
-                let typed_var_decl = ty::TyDecl::VariableDecl(Box::new(ty::TyVariableDecl {
-                    name: var_decl.name.clone(),
-                    body,
-                    mutability: ty::VariableMutability::new_from_ref_mut(
-                        false,
-                        var_decl.is_mutable,
-                    ),
-                    return_type,
-                    type_ascription,
-                }));
-                ctx.insert_symbol(handler, var_decl.name.clone(), typed_var_decl.clone())?;
+                let typed_var_decl = ty::TyDecl::VariableDecl(Box::new(var_decl));
+                ctx.insert_symbol(handler, name, typed_var_decl.clone())?;
                 typed_var_decl
             }
             parsed::Declaration::ConstantDeclaration(decl_id) => {
@@ -173,24 +104,24 @@ impl TyDecl {
                     Ok(res) => res,
                     Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
                 };
-                let typed_const_decl: ty::TyDecl = decl_engine.insert(const_decl.clone()).into();
+                let typed_const_decl: ty::TyDecl = decl_engine
+                    .insert(const_decl.clone(), Some(&decl_id))
+                    .into();
                 ctx.insert_symbol(handler, const_decl.name().clone(), typed_const_decl.clone())?;
                 typed_const_decl
             }
             parsed::Declaration::ConfigurableDeclaration(decl_id) => {
                 let decl = engines.pe().get_configurable(&decl_id).as_ref().clone();
                 let span = decl.span.clone();
-                let config_decl =
+                let name = decl.name.clone();
+                let typed_const_decl =
                     match ty::TyConfigurableDecl::type_check(handler, ctx.by_ref(), decl) {
-                        Ok(res) => res,
-                        Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
+                        Ok(config_decl) => ty::TyDecl::from(
+                            decl_engine.insert(config_decl.clone(), Some(&decl_id)),
+                        ),
+                        Err(err) => ty::TyDecl::ErrorRecovery(span, err),
                     };
-                let typed_const_decl: ty::TyDecl = decl_engine.insert(config_decl.clone()).into();
-                ctx.insert_symbol(
-                    handler,
-                    config_decl.name().clone(),
-                    typed_const_decl.clone(),
-                )?;
+                ctx.insert_symbol(handler, name, typed_const_decl.clone())?;
                 typed_const_decl
             }
             parsed::Declaration::TraitTypeDeclaration(decl_id) => {
@@ -200,7 +131,8 @@ impl TyDecl {
                     Ok(res) => res,
                     Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
                 };
-                let typed_type_decl: ty::TyDecl = decl_engine.insert(type_decl.clone()).into();
+                let typed_type_decl: ty::TyDecl =
+                    decl_engine.insert(type_decl.clone(), Some(&decl_id)).into();
                 ctx.insert_symbol(handler, type_decl.name().clone(), typed_type_decl.clone())?;
                 typed_type_decl
             }
@@ -212,7 +144,7 @@ impl TyDecl {
                     Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
                 };
                 let call_path = enum_decl.call_path.clone();
-                let decl: ty::TyDecl = decl_engine.insert(enum_decl).into();
+                let decl: ty::TyDecl = decl_engine.insert(enum_decl, Some(&decl_id)).into();
                 ctx.insert_symbol(handler, call_path.suffix, decl.clone())?;
 
                 decl
@@ -240,7 +172,7 @@ impl TyDecl {
                 };
 
                 let name = fn_decl.name.clone();
-                let decl: ty::TyDecl = decl_engine.insert(fn_decl).into();
+                let decl: ty::TyDecl = decl_engine.insert(fn_decl, Some(&decl_id)).into();
                 let _ = ctx.insert_symbol(handler, name, decl.clone());
                 decl
             }
@@ -278,7 +210,9 @@ impl TyDecl {
                         });
                 }
 
-                let decl: ty::TyDecl = decl_engine.insert(trait_decl.clone()).into();
+                let decl: ty::TyDecl = decl_engine
+                    .insert(trait_decl.clone(), Some(&decl_id))
+                    .into();
 
                 trait_decl
                     .items
@@ -287,16 +221,57 @@ impl TyDecl {
                 ctx.insert_symbol(handler, name, decl.clone())?;
                 decl
             }
-            parsed::Declaration::ImplTrait(decl_id) => {
-                let impl_trait = engines.pe().get_impl_trait(&decl_id).as_ref().clone();
-                let span = impl_trait.block_span.clone();
-                let mut impl_trait =
-                    match ty::TyImplTrait::type_check_impl_trait(handler, ctx.by_ref(), impl_trait)
-                    {
-                        Ok(res) => res,
+            parsed::Declaration::ImplSelfOrTrait(decl_id) => {
+                let impl_self_or_trait = engines
+                    .pe()
+                    .get_impl_self_or_trait(&decl_id)
+                    .as_ref()
+                    .clone();
+                let span = impl_self_or_trait.block_span.clone();
+                let mut impl_trait = if impl_self_or_trait.is_self {
+                    let impl_trait_decl = match ty::TyImplSelfOrTrait::type_check_impl_self(
+                        handler,
+                        ctx.by_ref(),
+                        &decl_id,
+                        impl_self_or_trait,
+                    ) {
+                        Ok(val) => val,
                         Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
                     };
 
+                    let impl_trait =
+                        if let TyDecl::ImplSelfOrTrait(impl_trait_id) = &impl_trait_decl {
+                            decl_engine.get_impl_self_or_trait(&impl_trait_id.decl_id)
+                        } else {
+                            unreachable!();
+                        };
+                    ctx.insert_trait_implementation(
+                        handler,
+                        impl_trait.trait_name.clone(),
+                        impl_trait.trait_type_arguments.clone(),
+                        impl_trait.implementing_for.type_id,
+                        &impl_trait.items,
+                        &impl_trait.span,
+                        impl_trait
+                            .trait_decl_ref
+                            .as_ref()
+                            .map(|decl_ref| decl_ref.decl_span().clone()),
+                        IsImplSelf::Yes,
+                        IsExtendingExistingImpl::No,
+                    )?;
+
+                    return Ok(impl_trait_decl);
+                } else {
+                    match ty::TyImplSelfOrTrait::type_check_impl_trait(
+                        handler,
+                        ctx.by_ref(),
+                        impl_self_or_trait,
+                    ) {
+                        Ok(res) => res,
+                        Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
+                    }
+                };
+
                 // Insert prefixed symbols when implementing_for is Contract
                 let is_contract = engines
                     .te()
@@ -306,6 +281,7 @@ impl TyDecl {
                     for i in &impl_trait.items {
                         if let ty::TyTraitItem::Fn(f) = i {
                             let decl = engines.de().get(f.id());
+                            let collecting_unifications = ctx.collecting_unifications();
                             let _ = ctx.namespace.module_mut(ctx.engines()).write(engines, |m| {
                                 m.current_items_mut().insert_typed_symbol(
                                     handler,
@@ -317,6 +293,7 @@ impl TyDecl {
                                     TyDecl::FunctionDecl(FunctionDecl { decl_id: *f.id() }),
                                     ConstShadowingMode::ItemStyle,
                                     GenericShadowingMode::Allow,
+                                    collecting_unifications,
                                 )
                             });
                         }
@@ -353,41 +330,14 @@ impl TyDecl {
                     IsImplSelf::No,
                     IsExtendingExistingImpl::No,
                 )?;
-                let impl_trait_decl: ty::TyDecl = decl_engine.insert(impl_trait.clone()).into();
+                let impl_trait_decl: ty::TyDecl = decl_engine
+                    .insert(impl_trait.clone(), Some(&decl_id))
+                    .into();
                 impl_trait.items.iter_mut().for_each(|item| {
                     item.replace_implementing_type(engines, impl_trait_decl.clone());
                 });
                 impl_trait_decl
             }
-            parsed::Declaration::ImplSelf(decl_id) => {
-                let impl_self = engines.pe().get_impl_self(&decl_id).as_ref().clone();
-                let span = impl_self.block_span.clone();
-                let impl_trait_decl =
-                    match ty::TyImplTrait::type_check_impl_self(handler, ctx.by_ref(), impl_self) {
-                        Ok(val) => val,
-                        Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
-                    };
-                let impl_trait = if let TyDecl::ImplTrait(impl_trait_id) = &impl_trait_decl {
-                    decl_engine.get_impl_trait(&impl_trait_id.decl_id)
-                } else {
-                    unreachable!();
-                };
-                ctx.insert_trait_implementation(
-                    handler,
-                    impl_trait.trait_name.clone(),
-                    impl_trait.trait_type_arguments.clone(),
-                    impl_trait.implementing_for.type_id,
-                    &impl_trait.items,
-                    &impl_trait.span,
-                    impl_trait
-                        .trait_decl_ref
-                        .as_ref()
-                        .map(|decl_ref| decl_ref.decl_span().clone()),
-                    IsImplSelf::Yes,
-                    IsExtendingExistingImpl::No,
-                )?;
-                impl_trait_decl
-            }
             parsed::Declaration::StructDeclaration(decl_id) => {
                 let decl = engines.pe().get_struct(&decl_id).as_ref().clone();
                 let span = decl.span.clone();
@@ -399,7 +349,7 @@ impl TyDecl {
                         }
                     };
                 let call_path = decl.call_path.clone();
-                let decl: ty::TyDecl = decl_engine.insert(decl).into();
+                let decl: ty::TyDecl = decl_engine.insert(decl, Some(&decl_id)).into();
 
                 // insert the struct decl into namespace
                 ctx.insert_symbol(handler, call_path.suffix, decl.clone())?;
@@ -442,7 +392,7 @@ impl TyDecl {
                         });
                 }
 
-                let decl: ty::TyDecl = decl_engine.insert(abi_decl.clone()).into();
+                let decl: ty::TyDecl = decl_engine.insert(abi_decl.clone(), Some(&decl_id)).into();
                 abi_decl
                     .items
                     .iter_mut()
@@ -550,7 +500,7 @@ impl TyDecl {
                     attributes,
                     storage_keyword,
                 };
-                let decl_ref = decl_engine.insert(decl);
+                let decl_ref = decl_engine.insert(decl, Some(&decl_id));
                 // insert the storage declaration into the symbols
                 // if there already was one, return an error that duplicate storage
 
@@ -591,12 +541,15 @@ impl TyDecl {
                     span,
                 };
 
-                let decl: ty::TyDecl = decl_engine.insert(decl).into();
+                let decl: ty::TyDecl = decl_engine.insert(decl, Some(&decl_id)).into();
 
                 // insert the type alias name and decl into namespace
                 ctx.insert_symbol(handler, name, decl.clone())?;
                 decl
             }
+            parsed::Declaration::TraitFnDeclaration(_decl_id) => {
+                unreachable!();
+            }
         };
 
         Ok(decl)
@@ -610,8 +563,8 @@ impl TypeCheckAnalysis for TyDecl {
         ctx: &mut TypeCheckAnalysisContext,
     ) -> Result<(), ErrorEmitted> {
         match self {
-            TyDecl::VariableDecl(node) => {
-                node.type_check_analyze(handler, ctx)?;
+            TyDecl::VariableDecl(var_decl) => {
+                var_decl.type_check_analyze(handler, ctx)?;
             }
             TyDecl::ConstantDecl(node) => {
                 let const_decl = ctx.engines.de().get_constant(&node.decl_id);
@@ -638,7 +591,7 @@ impl TypeCheckAnalysis for TyDecl {
                 enum_decl.type_check_analyze(handler, ctx)?;
             }
             TyDecl::EnumVariantDecl(_) => {}
-            TyDecl::ImplTrait(node) => {
+            TyDecl::ImplSelfOrTrait(node) => {
                 node.type_check_analyze(handler, ctx)?;
             }
             TyDecl::AbiDecl(node) => {
@@ -695,8 +648,8 @@ impl TypeCheckFinalization for TyDecl {
                 enum_decl.type_check_finalize(handler, ctx)?;
             }
             TyDecl::EnumVariantDecl(_) => {}
-            TyDecl::ImplTrait(node) => {
-                let mut impl_trait = (*decl_engine.get_impl_trait(&node.decl_id)).clone();
+            TyDecl::ImplSelfOrTrait(node) => {
+                let mut impl_trait = (*decl_engine.get_impl_self_or_trait(&node.decl_id)).clone();
                 impl_trait.type_check_finalize(handler, ctx)?;
             }
             TyDecl::AbiDecl(node) => {
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/enum.rs b/sway-core/src/semantic_analysis/ast_node/declaration/enum.rs
index f07975ee2d7..0434857f18f 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/enum.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/enum.rs
@@ -1,11 +1,33 @@
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     language::{parsed::*, ty, CallPath},
-    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
+    semantic_analysis::*,
     type_system::*,
+    Engines,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
+use symbol_collection_context::SymbolCollectionContext;
 
 impl ty::TyEnumDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<EnumDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let enum_decl = engines.pe().get_enum(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            enum_decl.name.clone(),
+            Declaration::EnumDeclaration(*decl_id),
+        )?;
+
+        // create a namespace for the decl, used to create a scope for generics
+        let _ = ctx.scoped(engines, enum_decl.span.clone(), |mut _ctx| Ok(()));
+        Ok(())
+    }
+
     pub fn type_check(
         handler: &Handler,
         ctx: TypeCheckContext,
@@ -22,7 +44,7 @@ impl ty::TyEnumDecl {
         } = decl;
 
         // create a namespace for the decl, used to create a scope for generics
-        ctx.scoped(|mut ctx| {
+        ctx.scoped(handler, Some(span.clone()), |mut ctx| {
             // Type check the type parameters.
             let new_type_parameters = TypeParameter::type_check_type_params(
                 handler,
@@ -61,7 +83,7 @@ impl ty::TyEnumDecl {
 impl ty::TyEnumVariant {
     pub(crate) fn type_check(
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         variant: EnumVariant,
     ) -> Result<Self, ErrorEmitted> {
         let type_engine = ctx.engines.te();
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/function.rs b/sway-core/src/semantic_analysis/ast_node/declaration/function.rs
index 45132000b9b..52ede5c3343 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/function.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/function.rs
@@ -5,20 +5,43 @@ use sway_error::{
     handler::{ErrorEmitted, Handler},
     warning::{CompileWarning, Warning},
 };
+use symbol_collection_context::SymbolCollectionContext;
 
 use crate::{
-    decl_engine::{DeclId, DeclRefFunction},
+    decl_engine::{parsed_id::ParsedDeclId, DeclId, DeclRefFunction},
     language::{
         parsed::*,
         ty::{self, TyCodeBlock, TyFunctionDecl},
         CallPath, Visibility,
     },
-    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
+    semantic_analysis::*,
     type_system::*,
+    Engines,
 };
 use sway_types::{style::is_snake_case, Spanned};
 
 impl ty::TyFunctionDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<FunctionDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let fn_decl = engines.pe().get_function(decl_id);
+        let _ = ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            fn_decl.name.clone(),
+            Declaration::FunctionDeclaration(*decl_id),
+        );
+
+        // create a namespace for the function
+        let _ = ctx.scoped(engines, fn_decl.span.clone(), |scoped_ctx| {
+            TyCodeBlock::collect(handler, engines, scoped_ctx, &fn_decl.body)
+        });
+        Ok(())
+    }
+
     pub fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,
@@ -83,10 +106,9 @@ impl ty::TyFunctionDecl {
 
         // create a namespace for the function
         ctx.by_ref()
-            .with_purity(*purity)
             .with_const_shadowing_mode(ConstShadowingMode::Sequential)
             .disallow_functions()
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(span.clone()), |mut ctx| {
                 // Type check the type parameters.
                 let new_type_parameters = TypeParameter::type_check_type_params(
                     handler,
@@ -181,15 +203,13 @@ impl ty::TyFunctionDecl {
     ) -> Result<Self, ErrorEmitted> {
         // create a namespace for the function
         ctx.by_ref()
-            .with_purity(ty_fn_decl.purity)
             .with_const_shadowing_mode(ConstShadowingMode::Sequential)
             .disallow_functions()
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(fn_decl.span.clone()), |mut ctx| {
                 let FunctionDeclaration { body, .. } = fn_decl;
 
                 let ty::TyFunctionDecl {
                     parameters,
-                    purity,
                     return_type,
                     type_parameters,
                     ..
@@ -212,14 +232,13 @@ impl ty::TyFunctionDecl {
 
                 let mut ctx = ctx
                     .by_ref()
-                    .with_purity(*purity)
                     .with_help_text(
                         "Function body's return type does not match up with its return type annotation.",
                     )
                     .with_type_annotation(return_type.type_id)
                     .with_function_type_annotation(return_type.type_id);
 
-                let body = ty::TyCodeBlock::type_check(handler, ctx.by_ref(), body)
+                let body = ty::TyCodeBlock::type_check(handler, ctx.by_ref(), body, true)
                     .unwrap_or_else(|_err| ty::TyCodeBlock::default());
 
                 ty_fn_decl.body = body;
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/function/function_parameter.rs b/sway-core/src/semantic_analysis/ast_node/declaration/function/function_parameter.rs
index f32fdfa4c31..324a2d14404 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/function/function_parameter.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/function/function_parameter.rs
@@ -1,6 +1,6 @@
 use crate::{
     language::{parsed::FunctionParameter, ty},
-    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
+    semantic_analysis::TypeCheckContext,
     type_system::*,
 };
 
@@ -13,7 +13,7 @@ use sway_types::Spanned;
 impl ty::TyFunctionParameter {
     pub(crate) fn type_check(
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         parameter: FunctionParameter,
     ) -> Result<Self, ErrorEmitted> {
         let type_engine = ctx.engines.te();
@@ -67,7 +67,7 @@ impl ty::TyFunctionParameter {
 
     pub(crate) fn type_check_interface_parameter(
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         parameter: &FunctionParameter,
     ) -> Result<Self, ErrorEmitted> {
         let type_engine = ctx.engines.te();
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs b/sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs
index 1f022a1b15b..033fe5cff9b 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs
@@ -11,35 +11,71 @@ use sway_error::{
 use sway_types::{Ident, Span, Spanned};
 
 use crate::{
-    decl_engine::*,
+    decl_engine::{parsed_id::ParsedDeclId, *},
     engine_threading::*,
     language::{
         parsed::*,
-        ty::{self, TyDecl, TyImplItem, TyImplTrait, TyTraitInterfaceItem, TyTraitItem},
+        ty::{
+            self, TyConstantDecl, TyDecl, TyFunctionDecl, TyImplItem, TyImplSelfOrTrait,
+            TyTraitInterfaceItem, TyTraitItem, TyTraitType,
+        },
         *,
     },
     namespace::{IsExtendingExistingImpl, IsImplSelf, TryInsertingTraitImplOnFailure},
     semantic_analysis::{
-        type_check_context::EnforceTypeArguments, AbiMode, ConstShadowingMode,
+        symbol_collection_context::SymbolCollectionContext, AbiMode, ConstShadowingMode,
         TyNodeDepGraphNodeId, TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckContext,
         TypeCheckFinalization, TypeCheckFinalizationContext,
     },
     type_system::*,
 };
 
-impl TyImplTrait {
+impl TyImplSelfOrTrait {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<ImplSelfOrTrait>,
+    ) -> Result<(), ErrorEmitted> {
+        let impl_trait = engines.pe().get_impl_self_or_trait(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            impl_trait.trait_name.suffix.clone(),
+            Declaration::ImplSelfOrTrait(*decl_id),
+        )?;
+
+        let _ = ctx.scoped(engines, impl_trait.block_span.clone(), |scoped_ctx| {
+            impl_trait.items.iter().for_each(|item| match item {
+                ImplItem::Fn(decl_id) => {
+                    let _ = TyFunctionDecl::collect(handler, engines, scoped_ctx, decl_id);
+                }
+                ImplItem::Constant(decl_id) => {
+                    let _ = TyConstantDecl::collect(handler, engines, scoped_ctx, decl_id);
+                }
+                ImplItem::Type(decl_id) => {
+                    let _ = TyTraitType::collect(handler, engines, scoped_ctx, decl_id);
+                }
+            });
+            Ok(())
+        });
+        Ok(())
+    }
+
     pub(crate) fn type_check_impl_trait(
         handler: &Handler,
         mut ctx: TypeCheckContext,
-        impl_trait: ImplTrait,
+        impl_trait: ImplSelfOrTrait,
     ) -> Result<Self, ErrorEmitted> {
-        let ImplTrait {
+        let ImplSelfOrTrait {
             impl_type_parameters,
             trait_name,
             mut trait_type_arguments,
+            trait_decl_ref: _,
             mut implementing_for,
             items,
             block_span,
+            ..
         } = impl_trait;
 
         let type_engine = ctx.engines.te();
@@ -55,7 +91,7 @@ impl TyImplTrait {
             .with_const_shadowing_mode(ConstShadowingMode::ItemStyle)
             .with_self_type(Some(self_type_id))
             .allow_functions()
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(block_span.clone()), |mut ctx| {
                 // Type check the type parameters
                 let new_impl_type_parameters = TypeParameter::type_check_type_params(
                     handler,
@@ -161,7 +197,7 @@ impl TyImplTrait {
                             implementing_for.type_id,
                         );
 
-                        let new_items = type_check_trait_implementation(
+                        let (new_items, supertrait_items) = type_check_trait_implementation(
                             handler,
                             ctx.by_ref(),
                             implementing_for.type_id,
@@ -177,7 +213,7 @@ impl TyImplTrait {
                             &block_span,
                             false,
                         )?;
-                        ty::TyImplTrait {
+                        ty::TyImplSelfOrTrait {
                             impl_type_parameters: new_impl_type_parameters,
                             trait_name: trait_name.clone(),
                             trait_type_arguments,
@@ -188,6 +224,7 @@ impl TyImplTrait {
                             )),
                             span: block_span,
                             items: new_items,
+                            supertrait_items,
                             implementing_for,
                         }
                     }
@@ -238,7 +275,7 @@ impl TyImplTrait {
                             None,
                         );
 
-                        let new_items = type_check_trait_implementation(
+                        let (new_items, supertrait_items) = type_check_trait_implementation(
                             handler,
                             ctx.by_ref(),
                             implementing_for.type_id,
@@ -254,7 +291,7 @@ impl TyImplTrait {
                             &block_span,
                             true,
                         )?;
-                        ty::TyImplTrait {
+                        ty::TyImplSelfOrTrait {
                             impl_type_parameters: vec![], // this is empty because abi definitions don't support generics
                             trait_name,
                             trait_type_arguments: vec![], // this is empty because abi definitions don't support generics
@@ -265,6 +302,7 @@ impl TyImplTrait {
                             )),
                             span: block_span,
                             items: new_items,
+                            supertrait_items,
                             implementing_for,
                         }
                     }
@@ -282,13 +320,15 @@ impl TyImplTrait {
     pub(crate) fn type_check_impl_self(
         handler: &Handler,
         ctx: TypeCheckContext,
-        impl_self: ImplSelf,
+        parsed_decl_id: &ParsedDeclId<ImplSelfOrTrait>,
+        impl_self: ImplSelfOrTrait,
     ) -> Result<ty::TyDecl, ErrorEmitted> {
-        let ImplSelf {
+        let ImplSelfOrTrait {
             impl_type_parameters,
             mut implementing_for,
             items,
             block_span,
+            ..
         } = impl_self;
 
         let type_engine = ctx.engines.te();
@@ -298,7 +338,7 @@ impl TyImplTrait {
         // create the namespace for the impl
         ctx.with_const_shadowing_mode(ConstShadowingMode::ItemStyle)
             .allow_functions()
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(block_span.clone()), |mut ctx| {
                 // Create a new type parameter for the "self type".
                 let self_type_param =
                     TypeParameter::new_self_type(engines, implementing_for.span());
@@ -393,7 +433,9 @@ impl TyImplTrait {
                                     Ok(res) => res,
                                     Err(_) => continue,
                                 };
-                                new_items.push(TyImplItem::Fn(decl_engine.insert(fn_decl)));
+                                new_items.push(TyImplItem::Fn(
+                                    decl_engine.insert(fn_decl, Some(fn_decl_id)),
+                                ));
                             }
                             ImplItem::Constant(decl_id) => {
                                 let const_decl =
@@ -406,7 +448,7 @@ impl TyImplTrait {
                                     Ok(res) => res,
                                     Err(_) => continue,
                                 };
-                                let decl_ref = decl_engine.insert(const_decl);
+                                let decl_ref = decl_engine.insert(const_decl, Some(decl_id));
                                 new_items.push(TyImplItem::Constant(decl_ref.clone()));
 
                                 ctx.insert_symbol(
@@ -428,19 +470,20 @@ impl TyImplTrait {
                                     Ok(res) => res,
                                     Err(_) => continue,
                                 };
-                                let decl_ref = decl_engine.insert(type_decl);
+                                let decl_ref = decl_engine.insert(type_decl, Some(decl_id));
                                 new_items.push(TyImplItem::Type(decl_ref.clone()));
                             }
                         }
                     }
 
-                    let mut impl_trait = ty::TyImplTrait {
+                    let mut impl_trait = ty::TyImplSelfOrTrait {
                         impl_type_parameters: new_impl_type_parameters,
                         trait_name,
                         trait_type_arguments: vec![], // this is empty because impl self's don't support generics on the "Self" trait,
                         trait_decl_ref: None,
                         span: block_span,
                         items: new_items,
+                        supertrait_items: vec![],
                         implementing_for,
                     };
 
@@ -459,11 +502,6 @@ impl TyImplTrait {
                         IsExtendingExistingImpl::No,
                     )?;
 
-                    // Now lets do a partial type check of the body of the functions (while deferring full
-                    // monomorphization of function applications). We will use this tree to perform type check
-                    // analysis (mainly dependency analysis), and re-type check the items ordered by dependency.
-                    let mut defer_ctx = ctx.by_ref().with_defer_monomorphization();
-
                     let new_items = &impl_trait.items;
                     for (item, new_item) in items.clone().into_iter().zip(new_items) {
                         match (item, new_item) {
@@ -473,7 +511,7 @@ impl TyImplTrait {
                                     (*decl_engine.get_function(decl_ref.id())).clone();
                                 let new_ty_fn_decl = match ty::TyFunctionDecl::type_check_body(
                                     handler,
-                                    defer_ctx.by_ref(),
+                                    ctx.by_ref(),
                                     &fn_decl,
                                     &mut ty_fn_decl,
                                 ) {
@@ -488,18 +526,25 @@ impl TyImplTrait {
                             (ImplItem::Type(_type_decl), TyTraitItem::Type(_decl_ref)) => {
                                 // Already processed.
                             }
-                            _ => unreachable!(),
+                            _ => {
+                                handler.emit_err(CompileError::Internal(
+                                    "Unexpected ImplItem tuple.",
+                                    Span::dummy(),
+                                ));
+                            }
                         }
                     }
 
-                    let impl_trait_decl = decl_engine.insert(impl_trait.clone()).into();
+                    let impl_trait_decl = decl_engine
+                        .insert(impl_trait.clone(), Some(parsed_decl_id))
+                        .into();
 
                     // First lets perform an analysis pass.
                     // This returns a vector with ordered indexes to the items in the order that they
                     // should be processed.
                     let ordered_node_indices_opt =
-                        if let TyDecl::ImplTrait(impl_trait) = &impl_trait_decl {
-                            ty::TyImplTrait::type_check_analyze_impl_self_items(
+                        if let TyDecl::ImplSelfOrTrait(impl_trait) = &impl_trait_decl {
+                            ty::TyImplSelfOrTrait::type_check_analyze_impl_self_items(
                                 handler,
                                 ctx.by_ref(),
                                 impl_trait,
@@ -539,11 +584,18 @@ impl TyImplTrait {
                             (ImplItem::Type(_type_decl), TyTraitItem::Type(_decl_ref)) => {
                                 // Already processed.
                             }
-                            _ => unreachable!(),
+                            _ => {
+                                handler.emit_err(CompileError::Internal(
+                                    "Unexpected ImplItem tuple.",
+                                    Span::dummy(),
+                                ));
+                            }
                         }
                     }
 
-                    let impl_trait_decl: ty::TyDecl = decl_engine.insert(impl_trait.clone()).into();
+                    let impl_trait_decl: ty::TyDecl = decl_engine
+                        .insert(impl_trait.clone(), Some(parsed_decl_id))
+                        .into();
 
                     let mut finalizing_ctx =
                         TypeCheckFinalizationContext::new(ctx.engines, ctx.by_ref());
@@ -570,7 +622,7 @@ impl TyImplTrait {
                         item.replace_implementing_type(engines, impl_trait_decl.clone())
                     });
 
-                    if let TyDecl::ImplTrait(impl_trait_id) = &impl_trait_decl {
+                    if let TyDecl::ImplSelfOrTrait(impl_trait_id) = &impl_trait_decl {
                         decl_engine.replace(impl_trait_id.decl_id, impl_trait);
                     }
 
@@ -582,7 +634,7 @@ impl TyImplTrait {
     pub(crate) fn type_check_analyze_impl_self_items(
         handler: &Handler,
         ctx: TypeCheckContext,
-        impl_self: &ty::ImplTrait,
+        impl_self: &ty::ImplSelfOrTrait,
     ) -> Result<Option<Vec<TyNodeDepGraphNodeId>>, ErrorEmitted> {
         let engines = ctx.engines;
         handler.scope(|handler| {
@@ -624,10 +676,11 @@ fn type_check_trait_implementation(
     trait_decl_span: &Span,
     block_span: &Span,
     is_contract: bool,
-) -> Result<Vec<TyImplItem>, ErrorEmitted> {
+) -> Result<(Vec<TyImplItem>, Vec<TyImplItem>), ErrorEmitted> {
     let type_engine = ctx.engines.te();
     let decl_engine = ctx.engines.de();
     let engines = ctx.engines();
+    let code_block_first_pass = ctx.code_block_first_pass();
 
     // Check to see if the type that we are implementing for implements the
     // supertraits of this trait.
@@ -646,6 +699,7 @@ fn type_check_trait_implementation(
                     block_span,
                     engines,
                     TryInsertingTraitImplOnFailure::Yes,
+                    code_block_first_pass.into(),
                 )
         })?;
 
@@ -785,14 +839,18 @@ fn type_check_trait_implementation(
                     ty::TyTraitType::error(ctx.engines(), type_decl.as_ref().clone())
                 });
 
-                type_decl.subst(&trait_type_mapping, engines);
+                type_decl.subst(&SubstTypesContext::new(
+                    engines,
+                    &trait_type_mapping,
+                    !ctx.code_block_first_pass(),
+                ));
 
                 // Remove this type from the checklist.
                 let name = type_decl.name.clone();
                 type_checklist.remove(&name);
 
                 // Add this type to the "impld decls".
-                let decl_ref = decl_engine.insert(type_decl.clone());
+                let decl_ref = decl_engine.insert(type_decl.clone(), Some(decl_id));
                 impld_item_refs.insert((name, implementing_for), TyTraitItem::Type(decl_ref));
 
                 let old_type_decl_info1 = TypeInfo::TraitType {
@@ -813,22 +871,28 @@ fn type_check_trait_implementation(
                         None,
                     ),
                 };
-                trait_type_mapping.extend(&TypeSubstMap::from_type_parameters_and_type_arguments(
-                    vec![type_engine.insert(
-                        engines,
-                        old_type_decl_info1,
-                        type_decl.name.span().source_id(),
-                    )],
-                    vec![type_decl.ty.clone().unwrap().type_id],
-                ));
-                trait_type_mapping.extend(&TypeSubstMap::from_type_parameters_and_type_arguments(
-                    vec![type_engine.insert(
-                        engines,
-                        old_type_decl_info2,
-                        type_decl.name.span().source_id(),
-                    )],
-                    vec![type_decl.ty.clone().unwrap().type_id],
-                ));
+                if let Some(type_arg) = type_decl.ty.clone() {
+                    trait_type_mapping.extend(
+                        &TypeSubstMap::from_type_parameters_and_type_arguments(
+                            vec![type_engine.insert(
+                                engines,
+                                old_type_decl_info1,
+                                type_decl.name.span().source_id(),
+                            )],
+                            vec![type_arg.type_id],
+                        ),
+                    );
+                    trait_type_mapping.extend(
+                        &TypeSubstMap::from_type_parameters_and_type_arguments(
+                            vec![type_engine.insert(
+                                engines,
+                                old_type_decl_info2,
+                                type_decl.name.span().source_id(),
+                            )],
+                            vec![type_arg.type_id],
+                        ),
+                    );
+                }
             }
         }
     }
@@ -850,14 +914,18 @@ fn type_check_trait_implementation(
                 )
                 .unwrap_or_else(|_| ty::TyFunctionDecl::error(&impl_method));
 
-                impl_method.subst(&trait_type_mapping, engines);
+                impl_method.subst(&SubstTypesContext::new(
+                    engines,
+                    &trait_type_mapping,
+                    !ctx.code_block_first_pass(),
+                ));
 
                 // Remove this method from the checklist.
                 let name = impl_method.name.clone();
                 method_checklist.remove(&name);
 
                 // Add this method to the "impld items".
-                let decl_ref = decl_engine.insert(impl_method);
+                let decl_ref = decl_engine.insert(impl_method, Some(impl_method_id));
                 impld_item_refs.insert((name, implementing_for), TyTraitItem::Fn(decl_ref));
             }
             ImplItem::Constant(decl_id) => {
@@ -873,14 +941,18 @@ fn type_check_trait_implementation(
                 )
                 .unwrap_or_else(|_| ty::TyConstantDecl::error(ctx.engines(), const_decl.clone()));
 
-                const_decl.subst(&trait_type_mapping, engines);
+                const_decl.subst(&SubstTypesContext::new(
+                    engines,
+                    &trait_type_mapping,
+                    !ctx.code_block_first_pass(),
+                ));
 
                 // Remove this constant from the checklist.
                 let name = const_decl.call_path.suffix.clone();
                 constant_checklist.remove(&name);
 
                 // Add this constant to the "impld decls".
-                let decl_ref = decl_engine.insert(const_decl);
+                let decl_ref = decl_engine.insert(const_decl, Some(decl_id));
                 impld_item_refs.insert((name, implementing_for), TyTraitItem::Constant(decl_ref));
             }
             ImplItem::Type(_) => {}
@@ -908,7 +980,7 @@ fn type_check_trait_implementation(
     type_mapping.extend(&trait_type_mapping);
 
     interface_item_refs.extend(supertrait_interface_item_refs);
-    impld_item_refs.extend(supertrait_impld_item_refs);
+    impld_item_refs.extend(supertrait_impld_item_refs.clone());
     let decl_mapping = DeclMapping::from_interface_and_item_and_impld_decl_refs(
         interface_item_refs,
         BTreeMap::new(),
@@ -943,23 +1015,44 @@ fn type_check_trait_implementation(
 
                 method.implementing_for_typeid = Some(implementing_for);
                 method.replace_decls(&decl_mapping, handler, &mut ctx)?;
-                method.subst(&type_mapping, engines);
+                method.subst(&SubstTypesContext::new(
+                    engines,
+                    &trait_type_mapping,
+                    !ctx.code_block_first_pass(),
+                ));
                 all_items_refs.push(TyImplItem::Fn(
                     decl_engine
-                        .insert(method)
+                        .insert(
+                            method,
+                            decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                        )
                         .with_parent(decl_engine, (*decl_ref.id()).into()),
                 ));
             }
             TyImplItem::Constant(decl_ref) => {
                 let mut const_decl = (*decl_engine.get_constant(decl_ref)).clone();
                 const_decl.replace_decls(&decl_mapping, handler, &mut ctx)?;
-                const_decl.subst(&type_mapping, engines);
-                all_items_refs.push(TyImplItem::Constant(decl_engine.insert(const_decl)));
+                const_decl.subst(&SubstTypesContext::new(
+                    engines,
+                    &trait_type_mapping,
+                    !ctx.code_block_first_pass(),
+                ));
+                all_items_refs.push(TyImplItem::Constant(decl_engine.insert(
+                    const_decl,
+                    decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                )));
             }
             TyImplItem::Type(decl_ref) => {
                 let mut type_decl = (*decl_engine.get_type(decl_ref)).clone();
-                type_decl.subst(&type_mapping, engines);
-                all_items_refs.push(TyImplItem::Type(decl_engine.insert(type_decl.clone())));
+                type_decl.subst(&SubstTypesContext::new(
+                    engines,
+                    &trait_type_mapping,
+                    !ctx.code_block_first_pass(),
+                ));
+                all_items_refs.push(TyImplItem::Type(decl_engine.insert(
+                    type_decl.clone(),
+                    decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                )));
             }
         }
     }
@@ -987,7 +1080,10 @@ fn type_check_trait_implementation(
             });
         }
 
-        Ok(all_items_refs)
+        Ok((
+            all_items_refs,
+            supertrait_impld_item_refs.values().cloned().collect(),
+        ))
     })
 }
 
@@ -1095,11 +1191,11 @@ fn type_check_impl_method(
 
             // this subst is required to replace associated types, namely TypeInfo::TraitType.
             let mut impl_method_param_type_id = impl_method_param.type_argument.type_id;
-            impl_method_param_type_id.subst(&ctx.type_subst(), engines);
+            impl_method_param_type_id.subst(&ctx.subst_ctx());
 
             let mut impl_method_signature_param_type_id =
                 impl_method_signature_param.type_argument.type_id;
-            impl_method_signature_param_type_id.subst(&ctx.type_subst(), engines);
+            impl_method_signature_param_type_id.subst(&ctx.subst_ctx());
 
             if !UnifyCheck::non_dynamic_equality(engines).check(
                 impl_method_param_type_id,
@@ -1169,11 +1265,11 @@ fn type_check_impl_method(
 
         // this subst is required to replace associated types, namely TypeInfo::TraitType.
         let mut impl_method_return_type_id = impl_method.return_type.type_id;
-        impl_method_return_type_id.subst(&ctx.type_subst(), engines);
+        impl_method_return_type_id.subst(&ctx.subst_ctx());
 
         let mut impl_method_signature_return_type_type_id =
             impl_method_signature.return_type.type_id;
-        impl_method_signature_return_type_type_id.subst(&ctx.type_subst(), engines);
+        impl_method_signature_return_type_type_id.subst(&ctx.subst_ctx());
 
         if !UnifyCheck::non_dynamic_equality(engines).check(
             impl_method_return_type_id,
@@ -1279,10 +1375,10 @@ fn type_check_const_decl(
 
     // this subst is required to replace associated types, namely TypeInfo::TraitType.
     let mut const_decl_type_id = const_decl.type_ascription.type_id;
-    const_decl_type_id.subst(&ctx.type_subst(), engines);
+    const_decl_type_id.subst(&ctx.subst_ctx());
 
     let mut const_decl_signature_type_id = const_decl_signature.type_ascription.type_id;
-    const_decl_signature_type_id.subst(&ctx.type_subst(), engines);
+    const_decl_signature_type_id.subst(&ctx.subst_ctx());
 
     // unify the types from the constant with the constant signature
     if !UnifyCheck::non_dynamic_equality(engines)
@@ -1542,21 +1638,20 @@ fn handle_supertraits(
     })
 }
 
-impl TypeCheckAnalysis for ty::ImplTrait {
+impl TypeCheckAnalysis for ty::ImplSelfOrTrait {
     fn type_check_analyze(
         &self,
         handler: &Handler,
         ctx: &mut TypeCheckAnalysisContext,
     ) -> Result<(), ErrorEmitted> {
         let decl_engine = ctx.engines.de();
-        let impl_trait = decl_engine.get_impl_trait(&self.decl_id);
+        let impl_trait = decl_engine.get_impl_self_or_trait(&self.decl_id);
 
         // Lets create a graph node for the impl trait and for every item in the trait.
         ctx.push_nodes_for_impl_trait(self);
 
         // Now lets analyze each impl trait item.
-        for (i, item) in impl_trait.items.iter().enumerate() {
-            let _node = ctx.items_node_stack[i];
+        for item in impl_trait.items.iter() {
             item.type_check_analyze(handler, ctx)?;
         }
 
@@ -1567,7 +1662,7 @@ impl TypeCheckAnalysis for ty::ImplTrait {
     }
 }
 
-impl TypeCheckFinalization for TyImplTrait {
+impl TypeCheckFinalization for TyImplSelfOrTrait {
     fn type_check_finalize(
         &mut self,
         handler: &Handler,
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs b/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs
index 525055e892e..ba84c359614 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs
@@ -14,5 +14,6 @@ mod r#trait;
 mod trait_fn;
 mod trait_type;
 mod type_alias;
+mod variable;
 
 pub(crate) use supertrait::*;
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/storage.rs b/sway-core/src/semantic_analysis/ast_node/declaration/storage.rs
index 8b0028f7333..08e0984b7ed 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/storage.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/storage.rs
@@ -1,16 +1,20 @@
 use std::collections::HashMap;
 
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     fuel_prelude::fuel_tx::StorageSlot,
     ir_generation::{
         const_eval::compile_constant_expression_to_constant,
         storage::{get_storage_key_string, serialize_to_storage_slots},
     },
-    language::ty::{self, TyExpression, TyStorageField},
+    language::{
+        parsed::StorageDeclaration,
+        ty::{self, TyExpression, TyStorageField},
+    },
     metadata::MetadataManager,
     semantic_analysis::{
-        TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckFinalization,
-        TypeCheckFinalizationContext,
+        symbol_collection_context::SymbolCollectionContext, TypeCheckAnalysis,
+        TypeCheckAnalysisContext, TypeCheckFinalization, TypeCheckFinalizationContext,
     },
     Engines,
 };
@@ -24,6 +28,15 @@ use sway_ir::{ConstantValue, Context, Module};
 use sway_types::{u256::U256, Spanned};
 
 impl ty::TyStorageDecl {
+    pub(crate) fn collect(
+        _handler: &Handler,
+        _engines: &Engines,
+        _ctx: &mut SymbolCollectionContext,
+        _decl_id: &ParsedDeclId<StorageDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        Ok(())
+    }
+
     pub(crate) fn get_initialized_storage_slots(
         &self,
         handler: &Handler,
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/struct.rs b/sway-core/src/semantic_analysis/ast_node/declaration/struct.rs
index a04efa0f274..0d3a7a25d34 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/struct.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/struct.rs
@@ -1,11 +1,33 @@
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     language::{parsed::*, ty, CallPath},
-    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
+    semantic_analysis::*,
     type_system::*,
+    Engines,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
+use symbol_collection_context::SymbolCollectionContext;
 
 impl ty::TyStructDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<StructDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let struct_decl = engines.pe().get_struct(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            struct_decl.name.clone(),
+            Declaration::StructDeclaration(*decl_id),
+        )?;
+
+        // create a namespace for the decl, used to create a scope for generics
+        let _ = ctx.scoped(engines, struct_decl.span.clone(), |_scoped_ctx| Ok(()));
+        Ok(())
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
         ctx: TypeCheckContext,
@@ -22,7 +44,7 @@ impl ty::TyStructDecl {
         } = decl;
 
         // create a namespace for the decl, used to create a scope for generics
-        ctx.scoped(|mut ctx| {
+        ctx.scoped(handler, Some(span.clone()), |mut ctx| {
             // Type check the type parameters.
             let new_type_parameters = TypeParameter::type_check_type_params(
                 handler,
@@ -57,7 +79,7 @@ impl ty::TyStructDecl {
 impl ty::TyStructField {
     pub(crate) fn type_check(
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         field: StructField,
     ) -> Result<Self, ErrorEmitted> {
         let type_engine = ctx.engines.te();
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/supertrait.rs b/sway-core/src/semantic_analysis/ast_node/declaration/supertrait.rs
index 83b9ca9ff7f..d74932eea9e 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/supertrait.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/supertrait.rs
@@ -2,7 +2,7 @@ use sway_error::error::CompileError;
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::{Span, Spanned};
 
-use crate::semantic_analysis::type_check_context::EnforceTypeArguments;
+use crate::EnforceTypeArguments;
 use crate::{
     language::{parsed, ty},
     semantic_analysis::TypeCheckContext,
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/trait.rs b/sway-core/src/semantic_analysis/ast_node/declaration/trait.rs
index 253b67ad5a4..9a0ed2942eb 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/trait.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/trait.rs
@@ -1,5 +1,6 @@
 use std::collections::{BTreeMap, HashSet};
 
+use parsed_id::ParsedDeclId;
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
@@ -11,19 +12,68 @@ use crate::{
     decl_engine::*,
     language::{
         parsed::*,
-        ty::{self, TyImplItem, TyTraitDecl, TyTraitItem},
+        ty::{
+            self, TyConstantDecl, TyFunctionDecl, TyImplItem, TyTraitDecl, TyTraitFn, TyTraitItem,
+            TyTraitType,
+        },
         CallPath,
     },
     namespace::{IsExtendingExistingImpl, IsImplSelf},
     semantic_analysis::{
         declaration::{insert_supertraits_into_namespace, SupertraitOf},
+        symbol_collection_context::SymbolCollectionContext,
         AbiMode, TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckContext,
         TypeCheckFinalization, TypeCheckFinalizationContext,
     },
     type_system::*,
+    Engines,
 };
 
+impl TyTraitItem {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        item: &TraitItem,
+    ) -> Result<(), ErrorEmitted> {
+        match item {
+            TraitItem::TraitFn(decl_id) => TyTraitFn::collect(handler, engines, ctx, decl_id),
+            TraitItem::Constant(decl_id) => TyConstantDecl::collect(handler, engines, ctx, decl_id),
+            TraitItem::Type(decl_id) => TyTraitType::collect(handler, engines, ctx, decl_id),
+            TraitItem::Error(_, _) => Ok(()),
+        }
+    }
+}
+
 impl TyTraitDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<TraitDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let trait_decl = engines.pe().get_trait(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            trait_decl.name.clone(),
+            Declaration::TraitDeclaration(*decl_id),
+        )?;
+
+        // A temporary namespace for checking within the trait's scope.
+        let _ = ctx.scoped(engines, trait_decl.span.clone(), |scoped_ctx| {
+            trait_decl.interface_surface.iter().for_each(|item| {
+                let _ = TyTraitItem::collect(handler, engines, scoped_ctx, item);
+            });
+
+            trait_decl.methods.iter().for_each(|decl_id| {
+                let _ = TyFunctionDecl::collect(handler, engines, scoped_ctx, decl_id);
+            });
+            Ok(())
+        });
+        Ok(())
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
         ctx: TypeCheckContext,
@@ -55,167 +105,177 @@ impl TyTraitDecl {
         let self_type = self_type_param.type_id;
 
         // A temporary namespace for checking within the trait's scope.
-        ctx.with_self_type(Some(self_type)).scoped(|mut ctx| {
-            // Type check the type parameters.
-            let new_type_parameters = TypeParameter::type_check_type_params(
-                handler,
-                ctx.by_ref(),
-                type_parameters,
-                Some(self_type_param.clone()),
-            )?;
-
-            // Recursively make the interface surfaces and methods of the
-            // supertraits available to this trait.
-            insert_supertraits_into_namespace(
-                handler,
-                ctx.by_ref(),
-                self_type,
-                &supertraits,
-                &SupertraitOf::Trait,
-            )?;
-
-            // type check the interface surface
-            let mut new_interface_surface = vec![];
-            let mut dummy_interface_surface = vec![];
-
-            let mut ids: HashSet<Ident> = HashSet::default();
-
-            for item in interface_surface.clone().into_iter() {
-                let decl_name = match item {
-                    TraitItem::TraitFn(_) => None,
-                    TraitItem::Constant(_) => None,
-                    TraitItem::Type(decl_id) => {
-                        let type_decl = engines.pe().get_trait_type(&decl_id).as_ref().clone();
-                        let type_decl =
-                            ty::TyTraitType::type_check(handler, ctx.by_ref(), type_decl.clone())?;
-                        let decl_ref = decl_engine.insert(type_decl.clone());
-                        dummy_interface_surface.push(ty::TyImplItem::Type(decl_ref.clone()));
-                        new_interface_surface
-                            .push(ty::TyTraitInterfaceItem::Type(decl_ref.clone()));
-
-                        Some(type_decl.name)
-                    }
-                    TraitItem::Error(_, _) => None,
-                };
+        ctx.with_self_type(Some(self_type))
+            .scoped(handler, Some(span.clone()), |mut ctx| {
+                // Type check the type parameters.
+                let new_type_parameters = TypeParameter::type_check_type_params(
+                    handler,
+                    ctx.by_ref(),
+                    type_parameters,
+                    Some(self_type_param.clone()),
+                )?;
+
+                // Recursively make the interface surfaces and methods of the
+                // supertraits available to this trait.
+                insert_supertraits_into_namespace(
+                    handler,
+                    ctx.by_ref(),
+                    self_type,
+                    &supertraits,
+                    &SupertraitOf::Trait,
+                )?;
+
+                // type check the interface surface
+                let mut new_interface_surface = vec![];
+                let mut dummy_interface_surface = vec![];
+
+                let mut ids: HashSet<Ident> = HashSet::default();
+
+                for item in interface_surface.clone().into_iter() {
+                    let decl_name = match item {
+                        TraitItem::TraitFn(_) => None,
+                        TraitItem::Constant(_) => None,
+                        TraitItem::Type(decl_id) => {
+                            let type_decl = engines.pe().get_trait_type(&decl_id).as_ref().clone();
+                            let type_decl = ty::TyTraitType::type_check(
+                                handler,
+                                ctx.by_ref(),
+                                type_decl.clone(),
+                            )?;
+                            let decl_ref = decl_engine.insert(type_decl.clone(), Some(&decl_id));
+                            dummy_interface_surface.push(ty::TyImplItem::Type(decl_ref.clone()));
+                            new_interface_surface
+                                .push(ty::TyTraitInterfaceItem::Type(decl_ref.clone()));
+
+                            Some(type_decl.name)
+                        }
+                        TraitItem::Error(_, _) => None,
+                    };
 
-                if let Some(decl_name) = decl_name {
-                    if !ids.insert(decl_name.clone()) {
-                        handler.emit_err(CompileError::MultipleDefinitionsOfName {
-                            name: decl_name.clone(),
-                            span: decl_name.span(),
-                        });
+                    if let Some(decl_name) = decl_name {
+                        if !ids.insert(decl_name.clone()) {
+                            handler.emit_err(CompileError::MultipleDefinitionsOfName {
+                                name: decl_name.clone(),
+                                span: decl_name.span(),
+                            });
+                        }
                     }
                 }
-            }
 
-            // insert placeholder functions representing the interface surface
-            // to allow methods to use those functions
-            ctx.insert_trait_implementation(
-                handler,
-                CallPath::ident_to_fullpath(name.clone(), ctx.namespace),
-                new_type_parameters.iter().map(|x| x.into()).collect(),
-                self_type,
-                &dummy_interface_surface,
-                &span,
-                None,
-                IsImplSelf::No,
-                IsExtendingExistingImpl::No,
-            )?;
-            let mut dummy_interface_surface = vec![];
-
-            for item in interface_surface.into_iter() {
-                let decl_name = match item {
-                    TraitItem::TraitFn(decl_id) => {
-                        let method = engines.pe().get_trait_fn(&decl_id);
-                        let method = ty::TyTraitFn::type_check(handler, ctx.by_ref(), &method)?;
-                        let decl_ref = decl_engine.insert(method.clone());
-                        dummy_interface_surface.push(ty::TyImplItem::Fn(
-                            decl_engine
-                                .insert(method.to_dummy_func(AbiMode::NonAbi, Some(self_type)))
-                                .with_parent(decl_engine, (*decl_ref.id()).into()),
-                        ));
-                        new_interface_surface.push(ty::TyTraitInterfaceItem::TraitFn(decl_ref));
-                        Some(method.name.clone())
-                    }
-                    TraitItem::Constant(decl_id) => {
-                        let const_decl = engines.pe().get_constant(&decl_id).as_ref().clone();
-                        let const_decl =
-                            ty::TyConstantDecl::type_check(handler, ctx.by_ref(), const_decl)?;
-                        let decl_ref = ctx.engines.de().insert(const_decl.clone());
-                        new_interface_surface
-                            .push(ty::TyTraitInterfaceItem::Constant(decl_ref.clone()));
-
-                        let const_name = const_decl.call_path.suffix.clone();
-                        ctx.insert_symbol(
-                            handler,
-                            const_name.clone(),
-                            ty::TyDecl::ConstantDecl(ty::ConstantDecl {
-                                decl_id: *decl_ref.id(),
-                            }),
-                        )?;
-
-                        Some(const_name)
-                    }
-                    TraitItem::Type(_) => None,
-                    TraitItem::Error(_, _) => {
-                        continue;
-                    }
-                };
+                // insert placeholder functions representing the interface surface
+                // to allow methods to use those functions
+                ctx.insert_trait_implementation(
+                    handler,
+                    CallPath::ident_to_fullpath(name.clone(), ctx.namespace),
+                    new_type_parameters.iter().map(|x| x.into()).collect(),
+                    self_type,
+                    &dummy_interface_surface,
+                    &span,
+                    None,
+                    IsImplSelf::No,
+                    IsExtendingExistingImpl::No,
+                )?;
+                let mut dummy_interface_surface = vec![];
+
+                for item in interface_surface.into_iter() {
+                    let decl_name = match item {
+                        TraitItem::TraitFn(decl_id) => {
+                            let method = engines.pe().get_trait_fn(&decl_id);
+                            let method = ty::TyTraitFn::type_check(handler, ctx.by_ref(), &method)?;
+                            let decl_ref = decl_engine.insert(method.clone(), Some(&decl_id));
+                            dummy_interface_surface.push(ty::TyImplItem::Fn(
+                                decl_engine
+                                    .insert(
+                                        method.to_dummy_func(AbiMode::NonAbi, Some(self_type)),
+                                        None,
+                                    )
+                                    .with_parent(decl_engine, (*decl_ref.id()).into()),
+                            ));
+                            new_interface_surface.push(ty::TyTraitInterfaceItem::TraitFn(decl_ref));
+                            Some(method.name.clone())
+                        }
+                        TraitItem::Constant(decl_id) => {
+                            let const_decl = engines.pe().get_constant(&decl_id).as_ref().clone();
+                            let const_decl =
+                                ty::TyConstantDecl::type_check(handler, ctx.by_ref(), const_decl)?;
+                            let decl_ref =
+                                ctx.engines.de().insert(const_decl.clone(), Some(&decl_id));
+                            new_interface_surface
+                                .push(ty::TyTraitInterfaceItem::Constant(decl_ref.clone()));
+
+                            let const_name = const_decl.call_path.suffix.clone();
+                            ctx.insert_symbol(
+                                handler,
+                                const_name.clone(),
+                                ty::TyDecl::ConstantDecl(ty::ConstantDecl {
+                                    decl_id: *decl_ref.id(),
+                                }),
+                            )?;
+
+                            Some(const_name)
+                        }
+                        TraitItem::Type(_) => None,
+                        TraitItem::Error(_, _) => {
+                            continue;
+                        }
+                    };
 
-                if let Some(decl_name) = decl_name {
-                    if !ids.insert(decl_name.clone()) {
-                        handler.emit_err(CompileError::MultipleDefinitionsOfName {
-                            name: decl_name.clone(),
-                            span: decl_name.span(),
-                        });
+                    if let Some(decl_name) = decl_name {
+                        if !ids.insert(decl_name.clone()) {
+                            handler.emit_err(CompileError::MultipleDefinitionsOfName {
+                                name: decl_name.clone(),
+                                span: decl_name.span(),
+                            });
+                        }
                     }
                 }
-            }
 
-            // insert placeholder functions representing the interface surface
-            // to allow methods to use those functions
-            ctx.insert_trait_implementation(
-                handler,
-                CallPath::ident_to_fullpath(name.clone(), ctx.namespace()),
-                new_type_parameters.iter().map(|x| x.into()).collect(),
-                self_type,
-                &dummy_interface_surface,
-                &span,
-                None,
-                IsImplSelf::No,
-                IsExtendingExistingImpl::Yes,
-            )?;
-
-            // Type check the items.
-            let mut new_items = vec![];
-            for method_decl_id in methods.into_iter() {
-                let method = engines.pe().get_function(&method_decl_id);
-                let method = ty::TyFunctionDecl::type_check(
+                // insert placeholder functions representing the interface surface
+                // to allow methods to use those functions
+                ctx.insert_trait_implementation(
                     handler,
-                    ctx.by_ref(),
-                    &method,
-                    true,
-                    false,
-                    Some(self_type_param.type_id),
-                )
-                .unwrap_or_else(|_| ty::TyFunctionDecl::error(&method));
-                new_items.push(ty::TyTraitItem::Fn(decl_engine.insert(method)));
-            }
+                    CallPath::ident_to_fullpath(name.clone(), ctx.namespace()),
+                    new_type_parameters.iter().map(|x| x.into()).collect(),
+                    self_type,
+                    &dummy_interface_surface,
+                    &span,
+                    None,
+                    IsImplSelf::No,
+                    IsExtendingExistingImpl::Yes,
+                )?;
+
+                // Type check the items.
+                let mut new_items = vec![];
+                for method_decl_id in methods.into_iter() {
+                    let method = engines.pe().get_function(&method_decl_id);
+                    let method = ty::TyFunctionDecl::type_check(
+                        handler,
+                        ctx.by_ref(),
+                        &method,
+                        true,
+                        false,
+                        Some(self_type_param.type_id),
+                    )
+                    .unwrap_or_else(|_| ty::TyFunctionDecl::error(&method));
+                    new_items.push(ty::TyTraitItem::Fn(
+                        decl_engine.insert(method, Some(&method_decl_id)),
+                    ));
+                }
 
-            let typed_trait_decl = ty::TyTraitDecl {
-                name: name.clone(),
-                type_parameters: new_type_parameters,
-                self_type: self_type_param,
-                interface_surface: new_interface_surface,
-                items: new_items,
-                supertraits,
-                visibility,
-                attributes,
-                call_path: CallPath::from(name).to_fullpath(ctx.engines(), ctx.namespace()),
-                span,
-            };
-            Ok(typed_trait_decl)
-        })
+                let typed_trait_decl = ty::TyTraitDecl {
+                    name: name.clone(),
+                    type_parameters: new_type_parameters,
+                    self_type: self_type_param,
+                    interface_surface: new_interface_surface,
+                    items: new_items,
+                    supertraits,
+                    visibility,
+                    attributes,
+                    call_path: CallPath::from(name).to_fullpath(ctx.engines(), ctx.namespace()),
+                    span,
+                };
+                Ok(typed_trait_decl)
+            })
     }
 
     /// Retrieves the interface surface and implemented items for this trait.
@@ -350,9 +410,19 @@ impl TyTraitDecl {
                 ty::TyTraitItem::Fn(decl_ref) => {
                     let mut method = (*decl_engine.get_function(&decl_ref)).clone();
                     let name = method.name.clone();
-                    let r = if method.subst(&type_mapping, engines).has_changes() {
+                    let r = if method
+                        .subst(&SubstTypesContext::new(
+                            engines,
+                            &type_mapping,
+                            !ctx.code_block_first_pass(),
+                        ))
+                        .has_changes()
+                    {
                         let new_ref = decl_engine
-                            .insert(method)
+                            .insert(
+                                method,
+                                decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                            )
                             .with_parent(decl_engine, (*decl_ref.id()).into());
                         new_ref
                     } else {
@@ -363,8 +433,18 @@ impl TyTraitDecl {
                 ty::TyTraitItem::Constant(decl_ref) => {
                     let mut const_decl = (*decl_engine.get_constant(&decl_ref)).clone();
                     let name = const_decl.call_path.suffix.clone();
-                    let r = if const_decl.subst(&type_mapping, engines).has_changes() {
-                        decl_engine.insert(const_decl)
+                    let r = if const_decl
+                        .subst(&SubstTypesContext::new(
+                            engines,
+                            &type_mapping,
+                            !ctx.code_block_first_pass(),
+                        ))
+                        .has_changes()
+                    {
+                        decl_engine.insert(
+                            const_decl,
+                            decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                        )
                     } else {
                         decl_ref.clone()
                     };
@@ -373,8 +453,16 @@ impl TyTraitDecl {
                 ty::TyTraitItem::Type(decl_ref) => {
                     let mut t = (*decl_engine.get_type(&decl_ref)).clone();
                     let name = t.name.clone();
-                    let r = if t.subst(&type_mapping, engines).has_changes() {
-                        decl_engine.insert(t)
+                    let r = if t
+                        .subst(&SubstTypesContext::new(
+                            engines,
+                            &type_mapping,
+                            !ctx.code_block_first_pass(),
+                        ))
+                        .has_changes()
+                    {
+                        decl_engine
+                            .insert(t, decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref())
                     } else {
                         decl_ref.clone()
                     };
@@ -424,11 +512,14 @@ impl TyTraitDecl {
             match item {
                 ty::TyTraitInterfaceItem::TraitFn(decl_ref) => {
                     let mut method = (*decl_engine.get_trait_fn(decl_ref)).clone();
-                    method.subst(&type_mapping, engines);
+                    method.subst(&SubstTypesContext::new(
+                        engines,
+                        &type_mapping,
+                        !ctx.code_block_first_pass(),
+                    ));
                     all_items.push(TyImplItem::Fn(
-                        ctx.engines
-                            .de()
-                            .insert(method.to_dummy_func(AbiMode::NonAbi, Some(type_id)))
+                        decl_engine
+                            .insert(method.to_dummy_func(AbiMode::NonAbi, Some(type_id)), None)
                             .with_parent(ctx.engines.de(), (*decl_ref.id()).into()),
                     ));
                 }
@@ -453,23 +544,44 @@ impl TyTraitDecl {
             match item {
                 ty::TyTraitItem::Fn(decl_ref) => {
                     let mut method = (*decl_engine.get_function(decl_ref)).clone();
-                    method.subst(&type_mapping, engines);
+                    method.subst(&SubstTypesContext::new(
+                        engines,
+                        &type_mapping,
+                        !ctx.code_block_first_pass(),
+                    ));
                     all_items.push(TyImplItem::Fn(
                         ctx.engines
                             .de()
-                            .insert(method)
-                            .with_parent(ctx.engines.de(), (*decl_ref.id()).into()),
+                            .insert(
+                                method,
+                                decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                            )
+                            .with_parent(decl_engine, (*decl_ref.id()).into()),
                     ));
                 }
                 ty::TyTraitItem::Constant(decl_ref) => {
                     let mut const_decl = (*decl_engine.get_constant(decl_ref)).clone();
-                    const_decl.subst(&type_mapping, engines);
-                    all_items.push(TyImplItem::Constant(ctx.engines.de().insert(const_decl)));
+                    const_decl.subst(&SubstTypesContext::new(
+                        engines,
+                        &type_mapping,
+                        !ctx.code_block_first_pass(),
+                    ));
+                    all_items.push(TyImplItem::Constant(decl_engine.insert(
+                        const_decl,
+                        decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                    )));
                 }
                 ty::TyTraitItem::Type(decl_ref) => {
                     let mut type_decl = (*decl_engine.get_type(decl_ref)).clone();
-                    type_decl.subst(&type_mapping, engines);
-                    all_items.push(TyImplItem::Type(ctx.engines.de().insert(type_decl)));
+                    type_decl.subst(&SubstTypesContext::new(
+                        engines,
+                        &type_mapping,
+                        !ctx.code_block_first_pass(),
+                    ));
+                    all_items.push(TyImplItem::Type(decl_engine.insert(
+                        type_decl,
+                        decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                    )));
                 }
             }
         }
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/trait_fn.rs b/sway-core/src/semantic_analysis/ast_node/declaration/trait_fn.rs
index 453eed4b7ac..07bd2feee81 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/trait_fn.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/trait_fn.rs
@@ -1,9 +1,13 @@
 use sway_types::Spanned;
 
 use crate::{
-    decl_engine::DeclId,
-    language::{parsed, ty, CallPath, Visibility},
-    semantic_analysis::type_check_context::EnforceTypeArguments,
+    decl_engine::{parsed_id::ParsedDeclId, DeclId},
+    language::{
+        parsed::{self, Declaration, TraitFn},
+        ty, CallPath, Visibility,
+    },
+    semantic_analysis::symbol_collection_context::SymbolCollectionContext,
+    Engines,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
 
@@ -13,6 +17,23 @@ use crate::{
 };
 
 impl ty::TyTraitFn {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<TraitFn>,
+    ) -> Result<(), ErrorEmitted> {
+        let trait_fn = engines.pe().get_trait_fn(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            trait_fn.name.clone(),
+            Declaration::TraitFnDeclaration(*decl_id),
+        )?;
+        let _ = ctx.scoped(engines, trait_fn.span.clone(), |_scoped_ctx| Ok(()));
+        Ok(())
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,
@@ -31,7 +52,7 @@ impl ty::TyTraitFn {
         let engines = ctx.engines();
 
         // Create a namespace for the trait function.
-        ctx.by_ref().with_purity(*purity).scoped(|mut ctx| {
+        ctx.by_ref().scoped(handler, Some(span.clone()), |mut ctx| {
             // TODO: when we add type parameters to trait fns, type check them here
 
             // Type check the parameters.
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/trait_type.rs b/sway-core/src/semantic_analysis/ast_node/declaration/trait_type.rs
index 103c721321e..262c2a5ef36 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/trait_type.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/trait_type.rs
@@ -5,22 +5,38 @@ use sway_error::{
 use sway_types::Span;
 
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     language::{
-        parsed,
+        parsed::{self, Declaration, TraitTypeDeclaration},
         ty::{self, TyTraitType},
     },
     semantic_analysis::{
-        type_check_context::EnforceTypeArguments, TypeCheckAnalysis, TypeCheckAnalysisContext,
-        TypeCheckContext,
+        symbol_collection_context::SymbolCollectionContext, TypeCheckAnalysis,
+        TypeCheckAnalysisContext, TypeCheckContext,
     },
     type_system::*,
     Engines,
 };
 
 impl ty::TyTraitType {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<TraitTypeDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let trait_type_decl = engines.pe().get_trait_type(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            trait_type_decl.name.clone(),
+            Declaration::TraitTypeDeclaration(*decl_id),
+        )
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         trait_type: parsed::TraitTypeDeclaration,
     ) -> Result<Self, ErrorEmitted> {
         let parsed::TraitTypeDeclaration {
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/type_alias.rs b/sway-core/src/semantic_analysis/ast_node/declaration/type_alias.rs
index 90eb2ad673e..7bcf3fb06c3 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/type_alias.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/type_alias.rs
@@ -1,9 +1,34 @@
 use crate::{
-    language::ty::TyTypeAliasDecl,
-    semantic_analysis::{TypeCheckFinalization, TypeCheckFinalizationContext},
+    decl_engine::parsed_id::ParsedDeclId,
+    language::{
+        parsed::{Declaration, TypeAliasDeclaration},
+        ty::TyTypeAliasDecl,
+    },
+    semantic_analysis::{
+        symbol_collection_context::SymbolCollectionContext, TypeCheckFinalization,
+        TypeCheckFinalizationContext,
+    },
+    Engines,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
 
+impl TyTypeAliasDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<TypeAliasDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let type_alias = engines.pe().get_type_alias(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            type_alias.name.clone(),
+            Declaration::TypeAliasDeclaration(*decl_id),
+        )
+    }
+}
+
 impl TypeCheckFinalization for TyTypeAliasDecl {
     fn type_check_finalize(
         &mut self,
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/variable.rs b/sway-core/src/semantic_analysis/ast_node/declaration/variable.rs
new file mode 100644
index 00000000000..cd9bff70750
--- /dev/null
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/variable.rs
@@ -0,0 +1,139 @@
+use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
+    language::{
+        parsed::*,
+        ty::{self, TyExpression, TyVariableDecl},
+    },
+    namespace::ResolvedDeclaration,
+    semantic_analysis::*,
+    type_system::*,
+    Engines,
+};
+use sway_error::handler::{ErrorEmitted, Handler};
+use sway_types::Spanned;
+use symbol_collection_context::SymbolCollectionContext;
+
+impl ty::TyVariableDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<VariableDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let var_decl = engines.pe().get_variable(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            var_decl.name.clone(),
+            Declaration::VariableDeclaration(*decl_id),
+        )?;
+        TyExpression::collect(handler, engines, ctx, &var_decl.body)
+    }
+
+    pub fn type_check(
+        handler: &Handler,
+        ctx: TypeCheckContext,
+        var_decl: VariableDeclaration,
+    ) -> Result<Self, ErrorEmitted> {
+        let engines = &ctx.engines();
+        let type_engine = engines.te();
+
+        let mut type_ascription = var_decl.type_ascription.clone();
+
+        type_ascription.type_id = ctx
+            .resolve_type(
+                handler,
+                type_ascription.type_id,
+                &type_ascription.span,
+                EnforceTypeArguments::Yes,
+                None,
+            )
+            .unwrap_or_else(|err| type_engine.insert(engines, TypeInfo::ErrorRecovery(err), None));
+        let mut ctx = ctx
+            .with_type_annotation(type_ascription.type_id)
+            .with_help_text(
+                "Variable declaration's type annotation does not match up \
+                        with the assigned expression's type.",
+            );
+        let result = ty::TyExpression::type_check(handler, ctx.by_ref(), &var_decl.body);
+        let body = result
+            .unwrap_or_else(|err| ty::TyExpression::error(err, var_decl.name.span(), engines));
+
+        // TODO: Integers shouldn't be anything special. RHS expressions should be written in
+        //       a way to always use the context provided from the LHS, and if the LHS is
+        //       an integer, RHS should properly unify or type check should fail.
+        //       Remove this special case as a part of the initiative of improving type inference.
+        // Integers are special in the sense that we can't only rely on the type of `body`
+        // to get the type of the variable. The type of the variable *has* to follow
+        // `type_ascription` if `type_ascription` is a concrete integer type that does not
+        // conflict with the type of `body` (i.e. passes the type checking above).
+        let return_type = match &*type_engine.get(type_ascription.type_id) {
+            TypeInfo::UnsignedInteger(_) => type_ascription.type_id,
+            _ => match &*type_engine.get(body.return_type) {
+                // If RHS type check ends up in an error we want to use the
+                // provided type ascription as the variable type. E.g.:
+                //   let v: Struct<u8> = Struct<u64> { x: 0 }; // `v` should be "Struct<u8>".
+                //   let v: ExistingType = non_existing_identifier; // `v` should be "ExistingType".
+                //   let v = <some error>; // `v` will remain "{unknown}".
+                // TODO: Refine and improve this further. E.g.,
+                //   let v: Struct { /* MISSING FIELDS */ }; // Despite the error, `v` should be of type "Struct".
+                TypeInfo::ErrorRecovery(_) => type_ascription.type_id,
+                _ => body.return_type,
+            },
+        };
+
+        if !ctx.code_block_first_pass() {
+            let previous_symbol = ctx
+                .namespace()
+                .module(engines)
+                .current_items()
+                .check_symbols_unique_while_collecting_unifications(&var_decl.name.clone())
+                .ok();
+
+            if let Some(ResolvedDeclaration::Typed(ty::TyDecl::VariableDecl(variable_decl))) =
+                previous_symbol
+            {
+                type_engine.unify(
+                    handler,
+                    engines,
+                    body.return_type,
+                    variable_decl.body.return_type,
+                    &variable_decl.span(),
+                    "",
+                    None,
+                );
+            }
+        }
+
+        let typed_var_decl = ty::TyVariableDecl {
+            name: var_decl.name.clone(),
+            body,
+            mutability: ty::VariableMutability::new_from_ref_mut(false, var_decl.is_mutable),
+            return_type,
+            type_ascription,
+        };
+
+        Ok(typed_var_decl)
+    }
+}
+
+impl TypeCheckAnalysis for TyVariableDecl {
+    fn type_check_analyze(
+        &self,
+        handler: &Handler,
+        ctx: &mut TypeCheckAnalysisContext,
+    ) -> Result<(), ErrorEmitted> {
+        self.body.type_check_analyze(handler, ctx)?;
+        Ok(())
+    }
+}
+
+impl TypeCheckFinalization for TyVariableDecl {
+    fn type_check_finalize(
+        &mut self,
+        handler: &Handler,
+        ctx: &mut TypeCheckFinalizationContext,
+    ) -> Result<(), ErrorEmitted> {
+        self.body.type_check_finalize(handler, ctx)
+    }
+}
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs b/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
index 0a2ffbcc99f..0219bec7d15 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
@@ -10,9 +10,10 @@ use crate::{
     engine_threading::*,
     language::{
         parsed::{Expression, ExpressionKind},
-        ty, Literal,
+        ty::{self, TyIntrinsicFunctionKind},
+        Literal,
     },
-    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
+    semantic_analysis::TypeCheckContext,
     type_system::*,
 };
 
@@ -93,7 +94,7 @@ impl ty::TyIntrinsicFunctionKind {
                 type_check_contract_ret(handler, ctx, kind, arguments, type_arguments, span)
             }
             Intrinsic::EncodeBufferEmpty => {
-                type_check_encode_buffer_empty(ctx, kind, arguments, type_arguments, span)
+                type_check_encode_buffer_empty(handler, ctx, kind, arguments, type_arguments, span)
             }
             Intrinsic::EncodeBufferAppend => {
                 type_check_encode_append(handler, ctx, kind, arguments, type_arguments, span)
@@ -101,8 +102,268 @@ impl ty::TyIntrinsicFunctionKind {
             Intrinsic::EncodeBufferAsRawSlice => {
                 type_check_encode_as_raw_slice(handler, ctx, kind, arguments, type_arguments, span)
             }
+            Intrinsic::Slice => {
+                type_check_slice(handler, ctx, kind, arguments, type_arguments, span)
+            }
+            Intrinsic::ElemAt => type_check_elem_at(arguments, handler, kind, span, ctx),
+        }
+    }
+}
+
+fn type_check_elem_at(
+    arguments: &[Expression],
+    handler: &Handler,
+    kind: Intrinsic,
+    span: Span,
+    ctx: TypeCheckContext,
+) -> Result<(TyIntrinsicFunctionKind, TypeId), ErrorEmitted> {
+    if arguments.len() != 2 {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumArgs {
+            name: kind.to_string(),
+            expected: 2,
+            span,
+        }));
+    }
+
+    let type_engine = ctx.engines.te();
+    let engines = ctx.engines();
+
+    let mut ctx = ctx;
+
+    // check first argument
+    let first_argument_span = arguments[0].span.clone();
+    let first_argument_type = type_engine.insert(engines, TypeInfo::Unknown, None);
+    let first_argument_typed_expr = {
+        let ctx = ctx
+            .by_ref()
+            .with_help_text("")
+            .with_type_annotation(first_argument_type);
+        ty::TyExpression::type_check(handler, ctx, &arguments[0])?
+    };
+
+    // first argument can be ref to array or ref to slice
+    let elem_type = match &*type_engine.get(first_argument_type) {
+        TypeInfo::Ref {
+            referenced_type,
+            to_mutable_value,
+        } => match &*type_engine.get(referenced_type.type_id) {
+            TypeInfo::Array(elem_ty, _) | TypeInfo::Slice(elem_ty) => {
+                Some((*to_mutable_value, elem_ty.type_id))
+            }
+            _ => None,
+        },
+        _ => None,
+    };
+    let Some((to_mutable_value, elem_type_type_id)) = elem_type else {
+        return Err(handler.emit_err(CompileError::IntrinsicUnsupportedArgType {
+            name: kind.to_string(),
+            span: first_argument_span,
+            hint: "Only references to arrays or slices can be used as argument here".to_string(),
+        }));
+    };
+
+    // index argument
+    let index_type = type_engine.insert(
+        engines,
+        TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
+        None,
+    );
+    let index_typed_expr = {
+        let ctx = ctx
+            .by_ref()
+            .with_help_text("")
+            .with_type_annotation(index_type);
+        ty::TyExpression::type_check(handler, ctx, &arguments[1])?
+    };
+
+    let return_type = type_engine.insert(
+        engines,
+        TypeInfo::Ref {
+            to_mutable_value,
+            referenced_type: TypeArgument {
+                type_id: elem_type_type_id,
+                initial_type_id: elem_type_type_id,
+                span: Span::dummy(),
+                call_path_tree: None,
+            },
+        },
+        None,
+    );
+
+    Ok((
+        TyIntrinsicFunctionKind {
+            kind,
+            arguments: vec![first_argument_typed_expr, index_typed_expr],
+            type_arguments: vec![],
+            span,
+        },
+        return_type,
+    ))
+}
+
+fn type_check_slice(
+    handler: &Handler,
+    mut ctx: TypeCheckContext,
+    kind: sway_ast::Intrinsic,
+    arguments: &[Expression],
+    _type_arguments: &[TypeArgument],
+    span: Span,
+) -> Result<(ty::TyIntrinsicFunctionKind, TypeId), ErrorEmitted> {
+    if arguments.len() != 3 {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumArgs {
+            name: kind.to_string(),
+            expected: 3,
+            span,
+        }));
+    }
+
+    let type_engine = ctx.engines.te();
+    let engines = ctx.engines();
+
+    // start index argument
+    let start_type = type_engine.insert(
+        engines,
+        TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
+        None,
+    );
+    let start_ty_expr = {
+        let ctx = ctx
+            .by_ref()
+            .with_help_text("")
+            .with_type_annotation(start_type);
+        ty::TyExpression::type_check(handler, ctx, &arguments[1])?
+    };
+
+    // end index argument
+    let end_type = type_engine.insert(
+        engines,
+        TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
+        None,
+    );
+    let end_ty_expr = {
+        let ctx = ctx
+            .by_ref()
+            .with_help_text("")
+            .with_type_annotation(end_type);
+        ty::TyExpression::type_check(handler, ctx, &arguments[2])?
+    };
+
+    // check first argument
+    let first_argument_span = arguments[0].span.clone();
+    let first_argument_type = type_engine.insert(engines, TypeInfo::Unknown, None);
+    let first_argument_ty_expr = {
+        let ctx = ctx
+            .by_ref()
+            .with_help_text("")
+            .with_type_annotation(first_argument_type);
+        ty::TyExpression::type_check(handler, ctx, &arguments[0])?
+    };
+
+    // statically check start and end, if possible
+    let start_literal = start_ty_expr
+        .expression
+        .as_literal()
+        .and_then(|x| x.cast_value_to_u64());
+
+    let end_literal = end_ty_expr
+        .expression
+        .as_literal()
+        .and_then(|x| x.cast_value_to_u64());
+
+    if let (Some(start), Some(end)) = (start_literal, end_literal) {
+        if start > end {
+            return Err(
+                handler.emit_err(CompileError::InvalidRangeEndGreaterThanStart {
+                    start,
+                    end,
+                    span,
+                }),
+            );
         }
     }
+
+    fn create_ref_to_slice(
+        engines: &Engines,
+        to_mutable_value: bool,
+        elem_type_arg: TypeArgument,
+    ) -> TypeId {
+        let type_engine = engines.te();
+        let slice_type_id =
+            type_engine.insert(engines, TypeInfo::Slice(elem_type_arg.clone()), None);
+        let ref_to_slice_type = TypeInfo::Ref {
+            to_mutable_value,
+            referenced_type: TypeArgument {
+                type_id: slice_type_id,
+                initial_type_id: slice_type_id,
+                span: Span::dummy(),
+                call_path_tree: None,
+            },
+        };
+        type_engine.insert(engines, ref_to_slice_type, None)
+    }
+
+    // first argument can be ref to array or ref to slice
+    let err = CompileError::IntrinsicUnsupportedArgType {
+        name: kind.to_string(),
+        span: first_argument_span,
+        hint: "Only references to arrays or slices can be used as argument here".to_string(),
+    };
+    let r = match &*type_engine.get(first_argument_type) {
+        TypeInfo::Ref {
+            referenced_type,
+            to_mutable_value,
+        } => match &*type_engine.get(referenced_type.type_id) {
+            TypeInfo::Array(elem_type_arg, array_len) => {
+                let array_len = array_len.val() as u64;
+
+                if let Some(v) = start_literal {
+                    if v > array_len {
+                        return Err(handler.emit_err(CompileError::ArrayOutOfBounds {
+                            index: v,
+                            count: array_len,
+                            span,
+                        }));
+                    }
+                }
+
+                if let Some(v) = end_literal {
+                    if v > array_len {
+                        return Err(handler.emit_err(CompileError::ArrayOutOfBounds {
+                            index: v,
+                            count: array_len,
+                            span,
+                        }));
+                    }
+                }
+
+                Some((
+                    TyIntrinsicFunctionKind {
+                        kind,
+                        arguments: vec![first_argument_ty_expr, start_ty_expr, end_ty_expr],
+                        type_arguments: vec![],
+                        span,
+                    },
+                    create_ref_to_slice(engines, *to_mutable_value, elem_type_arg.clone()),
+                ))
+            }
+            TypeInfo::Slice(elem_type_arg) => Some((
+                TyIntrinsicFunctionKind {
+                    kind,
+                    arguments: vec![first_argument_ty_expr, start_ty_expr, end_ty_expr],
+                    type_arguments: vec![],
+                    span,
+                },
+                create_ref_to_slice(engines, *to_mutable_value, elem_type_arg.clone()),
+            )),
+            _ => None,
+        },
+        _ => None,
+    };
+
+    match r {
+        Some(r) => Ok(r),
+        None => Err(handler.emit_err(err)),
+    }
 }
 
 fn type_check_encode_as_raw_slice(
@@ -156,13 +417,20 @@ fn new_encoding_buffer_tuple(
 }
 
 fn type_check_encode_buffer_empty(
+    handler: &Handler,
     ctx: TypeCheckContext,
     kind: sway_ast::Intrinsic,
     arguments: &[Expression],
     _type_arguments: &[TypeArgument],
     span: Span,
 ) -> Result<(ty::TyIntrinsicFunctionKind, TypeId), ErrorEmitted> {
-    assert!(arguments.is_empty());
+    if !arguments.is_empty() {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumArgs {
+            name: kind.to_string(),
+            expected: 0,
+            span,
+        }));
+    }
 
     let type_engine = ctx.engines.te();
     let engines = ctx.engines();
@@ -224,6 +492,14 @@ fn type_check_encode_append(
     _type_arguments: &[TypeArgument],
     span: Span,
 ) -> Result<(ty::TyIntrinsicFunctionKind, TypeId), ErrorEmitted> {
+    if arguments.len() != 2 {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumArgs {
+            name: kind.to_string(),
+            expected: 2,
+            span,
+        }));
+    }
+
     let type_engine = ctx.engines.te();
     let engines = ctx.engines();
 
@@ -247,21 +523,25 @@ fn type_check_encode_append(
     };
 
     // only supported types
-    match &*engines.te().get(item_type) {
-        TypeInfo::Boolean
-        | TypeInfo::UnsignedInteger(IntegerBits::Eight)
-        | TypeInfo::UnsignedInteger(IntegerBits::Sixteen)
-        | TypeInfo::UnsignedInteger(IntegerBits::ThirtyTwo)
-        | TypeInfo::UnsignedInteger(IntegerBits::SixtyFour)
-        | TypeInfo::UnsignedInteger(IntegerBits::V256)
-        | TypeInfo::B256
-        | TypeInfo::StringArray(_)
-        | TypeInfo::StringSlice
-        | TypeInfo::RawUntypedSlice => {}
-        _ => {
-            return Err(handler.emit_err(CompileError::EncodingUnsupportedType { span: item_span }))
-        }
-    };
+    if item_type.is_concrete(engines, TreatNumericAs::Abstract) {
+        match &*engines.te().get(item_type) {
+            TypeInfo::Boolean
+            | TypeInfo::UnsignedInteger(IntegerBits::Eight)
+            | TypeInfo::UnsignedInteger(IntegerBits::Sixteen)
+            | TypeInfo::UnsignedInteger(IntegerBits::ThirtyTwo)
+            | TypeInfo::UnsignedInteger(IntegerBits::SixtyFour)
+            | TypeInfo::UnsignedInteger(IntegerBits::V256)
+            | TypeInfo::B256
+            | TypeInfo::StringArray(_)
+            | TypeInfo::StringSlice
+            | TypeInfo::RawUntypedSlice => {}
+            _ => {
+                return Err(
+                    handler.emit_err(CompileError::EncodingUnsupportedType { span: item_span })
+                )
+            }
+        };
+    }
 
     let kind = ty::TyIntrinsicFunctionKind {
         kind,
@@ -319,7 +599,6 @@ fn type_check_not(
                 received: engines.help_out(return_type).to_string(),
                 help_text: "".into(),
                 span,
-                internal: "8".into(),
             },
         ))),
     }
@@ -369,7 +648,7 @@ fn type_check_size_of_val(
 /// Constraints: None.
 fn type_check_size_of_type(
     handler: &Handler,
-    mut ctx: TypeCheckContext,
+    ctx: TypeCheckContext,
     kind: sway_ast::Intrinsic,
     arguments: &[Expression],
     type_arguments: &[TypeArgument],
@@ -431,7 +710,7 @@ fn type_check_size_of_type(
 /// Constraints: None.
 fn type_check_is_reference_type(
     handler: &Handler,
-    mut ctx: TypeCheckContext,
+    ctx: TypeCheckContext,
     kind: sway_ast::Intrinsic,
     _arguments: &[Expression],
     type_arguments: &[TypeArgument],
@@ -484,7 +763,7 @@ fn type_check_is_reference_type(
 /// Constraints: None.
 fn type_check_assert_is_str_array(
     handler: &Handler,
-    mut ctx: TypeCheckContext,
+    ctx: TypeCheckContext,
     kind: sway_ast::Intrinsic,
     _arguments: &[Expression],
     type_arguments: &[TypeArgument],
@@ -943,8 +1222,7 @@ fn type_check_state_store_word(
         None,
     ));
     let type_argument = type_arguments.first().map(|targ| {
-        let mut ctx =
-            ctx.with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None));
+        let ctx = ctx.with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None));
         let initial_type_info = type_engine
             .to_typeinfo(targ.type_id, &targ.span)
             .map_err(|e| handler.emit_err(e.into()))
@@ -1039,8 +1317,7 @@ fn type_check_state_quad(
     ));
     let number_of_slots_exp = ty::TyExpression::type_check(handler, ctx.by_ref(), &arguments[2])?;
     let type_argument = type_arguments.first().map(|targ| {
-        let mut ctx =
-            ctx.with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None));
+        let ctx = ctx.with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None));
         let initial_type_info = type_engine
             .to_typeinfo(targ.type_id, &targ.span)
             .map_err(|e| handler.emit_err(e.into()))
@@ -1237,7 +1514,6 @@ fn type_check_bitwise_binary_op(
                 received: engines.help_out(return_type).to_string(),
                 help_text: "".into(),
                 span,
-                internal: "7".into(),
             },
         ))),
     }
@@ -1312,7 +1588,6 @@ fn type_check_shift_binary_op(
                 received: engines.help_out(return_type).to_string(),
                 help_text: "Incorrect argument type".into(),
                 span: lhs.span,
-                internal: "6".into(),
             },
         ))),
     }
@@ -1535,7 +1810,7 @@ fn type_check_smo(
 
     // Type check the type argument
     let type_argument = type_arguments.first().map(|targ| {
-        let mut ctx = ctx
+        let ctx = ctx
             .by_ref()
             .with_help_text("")
             .with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None));
@@ -1578,14 +1853,7 @@ fn type_check_smo(
     );
     let data = ty::TyExpression::type_check(handler, ctx.by_ref(), &arguments[1])?;
 
-    // Type check the third argument which is the output index, so it has to be a `u64`.
-    let mut ctx = ctx.by_ref().with_type_annotation(type_engine.insert(
-        engines,
-        TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
-        None,
-    ));
-
-    // Type check the fourth argument which is the amount of coins to send, so it has to be a `u64`.
+    // Type check the third argument which is the amount of coins to send, so it has to be a `u64`.
     let mut ctx = ctx.by_ref().with_type_annotation(type_engine.insert(
         engines,
         TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
@@ -1604,20 +1872,37 @@ fn type_check_smo(
     ))
 }
 
-/// Signature: `__contract_call<T>()`
-/// Description: Calls another contract
+/// Signature: `__contract_ret(ptr: raw_ptr, len: u64) -> !`
+/// Description: Returns from contract. The returned data is located at the memory location `ptr` and has
+/// the length of `len` bytes.
 /// Constraints: None.
 fn type_check_contract_ret(
     handler: &Handler,
     mut ctx: TypeCheckContext,
-    _kind: sway_ast::Intrinsic,
+    kind: sway_ast::Intrinsic,
     arguments: &[Expression],
-    _type_arguments: &[TypeArgument],
-    _span: Span,
+    type_arguments: &[TypeArgument],
+    span: Span,
 ) -> Result<(ty::TyIntrinsicFunctionKind, TypeId), ErrorEmitted> {
     let type_engine = ctx.engines.te();
     let engines = ctx.engines();
 
+    if arguments.len() != 2 {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumArgs {
+            name: kind.to_string(),
+            expected: 2,
+            span,
+        }));
+    }
+
+    if !type_arguments.is_empty() {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumTArgs {
+            name: kind.to_string(),
+            expected: 0,
+            span,
+        }));
+    }
+
     let arguments: Vec<ty::TyExpression> = arguments
         .iter()
         .map(|x| {
@@ -1629,17 +1914,14 @@ fn type_check_contract_ret(
         })
         .collect::<Result<Vec<_>, _>>()?;
 
-    let t = ctx
-        .engines
-        .te()
-        .insert(ctx.engines, TypeInfo::Tuple(vec![]), None);
+    let t = ctx.engines.te().insert(ctx.engines, TypeInfo::Never, None);
 
     Ok((
         ty::TyIntrinsicFunctionKind {
             kind: Intrinsic::ContractRet,
             arguments,
             type_arguments: vec![],
-            span: Span::dummy(),
+            span,
         },
         t,
     ))
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/match_pattern_variables.rs
similarity index 82%
rename from sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs
rename to sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/match_pattern_variables.rs
index f368e01eeec..0e08b8b4371 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/match_pattern_variables.rs
@@ -175,7 +175,6 @@ pub(crate) fn collect_duplicate_match_pattern_variables(
             ty::TyScrutineeVariant::Variable(ident) => add_variable(left_most_branch, ident, false),
             ty::TyScrutineeVariant::Literal(_) => (),
             ty::TyScrutineeVariant::Constant { .. } => (),
-            ty::TyScrutineeVariant::Configurable { .. } => (),
             ty::TyScrutineeVariant::StructScrutinee { fields, .. } => {
                 // If a field does not have a scrutinee, the field itself is a variable.
                 for field in fields {
@@ -247,3 +246,49 @@ pub(crate) fn collect_duplicate_match_pattern_variables(
         }
     }
 }
+
+/// Returns [Ident]s for all match arm variables found in the `scrutinee`,
+/// together with the information if the variable is a struct field (true)
+/// or not (false), or empty [Vec] if there are no variables declared in
+/// the `scrutinee`.
+///
+/// If the `scrutinee` contains alternatives, and thus a variable is declared
+/// multiple times, each occurrence of the variable will be returned.
+pub(crate) fn collect_match_pattern_variables(scrutinee: &TyScrutinee) -> Vec<(Ident, bool)> {
+    let mut variables = vec![];
+
+    recursively_collect_variables(&mut variables, scrutinee);
+
+    return variables;
+
+    fn recursively_collect_variables(variables: &mut Vec<(Ident, bool)>, scrutinee: &TyScrutinee) {
+        match &scrutinee.variant {
+            ty::TyScrutineeVariant::CatchAll => (),
+            ty::TyScrutineeVariant::Variable(ident) => variables.push((ident.clone(), false)),
+            ty::TyScrutineeVariant::Literal(_) => (),
+            ty::TyScrutineeVariant::Constant { .. } => (),
+            ty::TyScrutineeVariant::StructScrutinee { fields, .. } => {
+                // If a field does not have a scrutinee, the field itself is a variable.
+                for field in fields {
+                    match &field.scrutinee {
+                        Some(scrutinee) => recursively_collect_variables(variables, scrutinee),
+                        None => variables.push((field.field.clone(), true)),
+                    }
+                }
+            }
+            ty::TyScrutineeVariant::Or(scrutinees) => {
+                for scrutinee in scrutinees {
+                    recursively_collect_variables(variables, scrutinee);
+                }
+            }
+            ty::TyScrutineeVariant::Tuple(scrutinees) => {
+                for scrutinee in scrutinees {
+                    recursively_collect_variables(variables, scrutinee);
+                }
+            }
+            ty::TyScrutineeVariant::EnumScrutinee { value, .. } => {
+                recursively_collect_variables(variables, value)
+            }
+        }
+    }
+}
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/mod.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/mod.rs
index ab43e75ec12..251672fa95f 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/mod.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/mod.rs
@@ -1,5 +1,5 @@
 mod constructor_factory;
-mod duplicates;
+mod match_pattern_variables;
 mod matrix;
 mod patstack;
 mod pattern;
@@ -8,6 +8,8 @@ mod reachable_report;
 mod usefulness;
 mod witness_report;
 
-pub(crate) use duplicates::collect_duplicate_match_pattern_variables;
+pub(crate) use match_pattern_variables::{
+    collect_duplicate_match_pattern_variables, collect_match_pattern_variables,
+};
 pub(in crate::semantic_analysis::ast_node::expression) use reachable_report::ReachableReport;
 pub(crate) use usefulness::check_match_expression_usefulness;
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs
index 3a0458d4fed..7de4cc88dc4 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs
@@ -120,7 +120,6 @@ impl Pattern {
             ty::TyScrutineeVariant::Variable(_) => Pattern::Wildcard,
             ty::TyScrutineeVariant::Literal(value) => Pattern::from_literal(value),
             ty::TyScrutineeVariant::Constant(_, value, _) => Pattern::from_literal(value),
-            ty::TyScrutineeVariant::Configurable(_, value, _) => Pattern::from_literal(value),
             ty::TyScrutineeVariant::StructScrutinee {
                 struct_ref,
                 fields,
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs
index 143ab749740..5ad8f4a40a0 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs
@@ -19,10 +19,10 @@ pub(crate) trait MyMath<T> {
 
 impl MyMath<u8> for u8 {
     fn global_max() -> u8 {
-        std::u8::MAX
+        u8::MAX
     }
     fn global_min() -> u8 {
-        std::u8::MIN
+        u8::MIN
     }
 
     fn incr(&self) -> u8 {
@@ -35,10 +35,10 @@ impl MyMath<u8> for u8 {
 
 impl MyMath<u16> for u16 {
     fn global_max() -> u16 {
-        std::u16::MAX
+        u16::MAX
     }
     fn global_min() -> u16 {
-        std::u16::MIN
+        u16::MIN
     }
 
     fn incr(&self) -> u16 {
@@ -51,10 +51,10 @@ impl MyMath<u16> for u16 {
 
 impl MyMath<u32> for u32 {
     fn global_max() -> u32 {
-        std::u32::MAX
+        u32::MAX
     }
     fn global_min() -> u32 {
-        std::u32::MIN
+        u32::MIN
     }
 
     fn incr(&self) -> u32 {
@@ -67,10 +67,10 @@ impl MyMath<u32> for u32 {
 
 impl MyMath<u64> for u64 {
     fn global_max() -> u64 {
-        std::u64::MAX
+        u64::MAX
     }
     fn global_min() -> u64 {
-        std::u64::MIN
+        u64::MIN
     }
 
     fn incr(&self) -> u64 {
@@ -119,8 +119,8 @@ where
 impl Range<u8> {
     pub(crate) fn u8() -> Range<u8> {
         Range {
-            first: std::u8::MIN,
-            last: std::u8::MAX,
+            first: u8::MIN,
+            last: u8::MAX,
         }
     }
 }
@@ -128,8 +128,8 @@ impl Range<u8> {
 impl Range<u16> {
     pub(crate) fn u16() -> Range<u16> {
         Range {
-            first: std::u16::MIN,
-            last: std::u16::MAX,
+            first: u16::MIN,
+            last: u16::MAX,
         }
     }
 }
@@ -137,8 +137,8 @@ impl Range<u16> {
 impl Range<u32> {
     pub(crate) fn u32() -> Range<u32> {
         Range {
-            first: std::u32::MIN,
-            last: std::u32::MAX,
+            first: u32::MIN,
+            last: u32::MAX,
         }
     }
 }
@@ -146,8 +146,8 @@ impl Range<u32> {
 impl Range<u64> {
     pub(crate) fn u64() -> Range<u64> {
         Range {
-            first: std::u64::MIN,
-            last: std::u64::MAX,
+            first: u64::MIN,
+            last: u64::MAX,
         }
     }
 }
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/usefulness.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/usefulness.rs
index 0f240e6d15c..560e90fbdda 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/usefulness.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/usefulness.rs
@@ -20,7 +20,7 @@ use super::{
 /// http://moscova.inria.fr/%7Emaranget/papers/warn/warn004.html
 ///
 /// Implemented in Rust here:
-/// https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/pattern/usefulness/index.html
+/// https://doc.rust-lang.org/1.75.0/nightly-rustc/rustc_mir_build/thir/pattern/usefulness/index.html
 ///
 /// ---
 ///
@@ -129,7 +129,7 @@ use super::{
 /// `2`, any cases that the pattern `2` covers would previously be caught by the
 /// catchall pattern.
 ///
-/// Usefulness used in the exhaustivity algorithm.
+/// Usefulness is used in the exhaustivity algorithm.
 ///
 /// # Witnesses
 ///
@@ -148,11 +148,11 @@ use super::{
 /// }
 /// ```
 ///
-/// the witness for pattern `1` would be the pattern "1" as the pattern `1`
+/// the witness for pattern `1` would be the value "1" as the pattern `1`
 /// would catch the concrete hypothetical matched value "1" and no other
 /// previous cases would have caught it. The witness for pattern `_` is an
 /// or-pattern of all of the remaining integers they wouldn't be caught by `0`
-/// and `1`, so "3 | .. | MAX".
+/// and `1`, so "2 | .. | MAX".
 ///
 /// Given:
 ///
@@ -166,7 +166,7 @@ use super::{
 /// }
 /// ```
 ///
-/// the pattern `1` (noted with an arrow) would not have any witnesses as there
+/// the pattern `1` (noted with an arrow) would not have any witnesses
 /// that it catches that are not caught by previous patterns.
 ///
 /// # Putting it all together
@@ -183,7 +183,7 @@ use super::{
 ///
 /// # Details
 ///
-/// This algorithm checks is a match expression is exhaustive and if its match
+/// This algorithm checks if a match expression is exhaustive and if its match
 /// arms are reachable by applying the above definitions of usefulness and
 /// witnesses. This algorithm sequentially creates a [WitnessReport] for every
 /// match arm by calling *U(P, q)*, where *P* is the [Matrix] of patterns seen
@@ -205,7 +205,7 @@ pub(crate) fn check_match_expression_usefulness(
     let mut matrix = Matrix::empty();
     let mut arms_reachability = vec![];
 
-    // If the provided type does has no valid constructor and there are no
+    // If the provided type does not have a valid constructor and there are no
     // branches in the match expression (i.e. no scrutinees to check), then
     // every scrutinee (i.e. 0 scrutinees) are useful! We return early in this
     // case.
@@ -489,7 +489,7 @@ fn is_useful_or(
 ) -> Result<WitnessReport, ErrorEmitted> {
     let (_, q_rest) = q.split_first(handler, span)?;
     let mut p = p.clone();
-    let mut witness_report = WitnessReport::Witnesses(PatStack::empty());
+    let mut witness_report = WitnessReport::NoWitnesses;
     for pat in pats.into_iter() {
         // 1. For each *k* 0..*a* compute *q'* as \[*rₖ q₂ ... qₙ*\].
         let mut v = PatStack::from_pattern(pat);
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs
index b36cef5600e..39cd872146d 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs
@@ -2,7 +2,7 @@ use indexmap::IndexMap;
 
 use crate::{
     language::{
-        ty::{self, TyConfigurableDecl, TyConstantDecl},
+        ty::{self, TyConstantDecl},
         CallPath, Literal,
     },
     semantic_analysis::{
@@ -229,9 +229,6 @@ pub(super) fn matcher(
         ty::TyScrutineeVariant::Constant(_, _, const_decl) => {
             Ok(match_constant(ctx, exp, const_decl, span))
         }
-        ty::TyScrutineeVariant::Configurable(_, _, config_decl) => {
-            Ok(match_configurable(ctx, exp, config_decl, span))
-        }
         ty::TyScrutineeVariant::StructScrutinee {
             struct_ref: _,
             fields,
@@ -422,31 +419,6 @@ fn match_constant(
     ReqDeclTree::req(req)
 }
 
-fn match_configurable(
-    ctx: TypeCheckContext,
-    exp: &ty::TyExpression,
-    decl: TyConfigurableDecl,
-    span: Span,
-) -> ReqDeclTree {
-    let name = decl.name().clone();
-    let return_type = decl.type_ascription.type_id;
-
-    let req = (
-        exp.to_owned(),
-        ty::TyExpression {
-            expression: ty::TyExpressionVariant::ConfigurableExpression {
-                span: span.clone(),
-                decl: Box::new(decl),
-                call_path: Some(CallPath::from(name).to_fullpath(ctx.engines(), ctx.namespace())),
-            },
-            return_type,
-            span,
-        },
-    );
-
-    ReqDeclTree::req(req)
-}
-
 fn match_struct(
     handler: &Handler,
     mut ctx: TypeCheckContext,
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_branch.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_branch.rs
index 254e98cd5c9..f8b530e2107 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_branch.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_branch.rs
@@ -1,7 +1,8 @@
 use ast_node::expression::match_expression::typed::matcher::{ReqDeclNode, ReqOrVarDecl};
+use indexmap::IndexSet;
 use itertools::{multiunzip, Itertools};
 use sway_error::{
-    error::CompileError,
+    error::{CompileError, ShadowingSource},
     handler::{ErrorEmitted, Handler},
 };
 use sway_types::{Ident, Span, Spanned};
@@ -43,10 +44,10 @@ impl ty::TyMatchBranch {
         let type_engine = ctx.engines.te();
         let engines = ctx.engines();
 
-        // type check the scrutinee
+        // Type check the scrutinee.
         let typed_scrutinee = ty::TyScrutinee::type_check(handler, ctx.by_ref(), scrutinee)?;
 
-        // calculate the requirements and variable declarations
+        // Calculate the requirements and variable declarations.
         let req_decl_tree = matcher(
             handler,
             ctx.by_ref(),
@@ -76,6 +77,48 @@ impl ty::TyMatchBranch {
             Ok(())
         })?;
 
+        // Emit errors for eventual uses of configurables in patterns.
+        // Configurables cannot be used in pattern matching, since they are not compile-time
+        // constants. Using a configurable will define a pattern variable, that will
+        // then shadow the configurable of the same name, which is not allowed.
+        // This can be very confusing in case someone tries to use configurables in pattern matching
+        // in the same way as constants. So we provide helpful hints here.
+        // We stop further compilation in case of finding configurables in patterns.
+        handler.scope(|handler| {
+            // All the first occurrences of variables in order of appearance, while respecting
+            // if they are struct field variables.
+            let variables: IndexSet<(Ident, bool)> =
+                IndexSet::from_iter(collect_match_pattern_variables(&typed_scrutinee));
+            for (ident, is_struct_field) in variables {
+                let default_handler = &Handler::default();
+                // If there exist a configurable with the same name as the pattern variable.
+                if let Ok(ty::TyDecl::ConfigurableDecl(configurable_decl)) = ctx
+                    .namespace()
+                    .resolve_symbol_typed(default_handler, engines, &ident, ctx.self_type())
+                {
+                    let name = (&ident).into();
+                    let configurable_span = engines
+                        .de()
+                        .get_configurable(&configurable_decl.decl_id)
+                        .span();
+                    if is_struct_field {
+                        handler.emit_err(CompileError::ConfigurablesCannotBeShadowed {
+                            shadowing_source: ShadowingSource::PatternMatchingStructFieldVar,
+                            name,
+                            configurable_span,
+                        });
+                    } else {
+                        handler.emit_err(CompileError::ConfigurablesCannotBeMatchedAgainst {
+                            name,
+                            configurable_span,
+                        });
+                    }
+                }
+            }
+
+            Ok(())
+        })?;
+
         let (condition, result_var_declarations, or_variant_vars) =
             instantiate_branch_condition_result_var_declarations_and_matched_or_variant_index_vars(
                 handler,
@@ -85,7 +128,7 @@ impl ty::TyMatchBranch {
             )?;
 
         // create a new namespace for this branch result
-        ctx.scoped(|mut scoped_ctx| {
+        ctx.scoped(handler, Some(branch_span.clone()), |mut scoped_ctx| {
             // for every variable that comes into result block, create a variable declaration,
             // insert it into the branch namespace, and add it to the block of code statements
             let mut code_block_contents: Vec<ty::TyAstNode> = vec![];
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs
index 9f415035b65..bd271a7f638 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs
@@ -1,20 +1,53 @@
-use std::ops::ControlFlow;
-
-use sway_error::handler::{ErrorEmitted, Handler};
-use sway_types::{Span, Spanned};
-
 use crate::{
     compiler_generated::INVALID_DESUGARED_MATCHED_EXPRESSION_SIGNAL,
     language::{
         parsed::*,
-        ty::{self, TyExpression},
+        ty::{
+            self, TyAsmRegisterDeclaration, TyExpression, TyExpressionVariant,
+            TyIntrinsicFunctionKind,
+        },
+        AsmOp, AsmRegister,
     },
     semantic_analysis::{
         ast_node::expression::typed_expression::instantiate_if_expression,
         expression::match_expression::typed::instantiate::Instantiate, TypeCheckContext,
     },
-    CompileError, TypeId,
+    CompileError, TypeId, TypeInfo,
 };
+use std::{collections::BTreeMap, ops::ControlFlow};
+use sway_error::handler::{ErrorEmitted, Handler};
+use sway_types::{BaseIdent, Ident, Span, Spanned};
+
+// Enable this to see a pseudo-code printed to understand what is being generated.
+const RADIX_TREE_DEBUG: bool = true;
+
+#[derive(Default, Debug, Clone)]
+struct TrieNode {
+    output: Option<usize>,
+    previous: Option<usize>,
+    next: BTreeMap<String, usize>,
+}
+
+struct Trie {
+    nodes: Vec<TrieNode>,
+}
+
+fn revert(never_type_id: TypeId, u64_type_id: TypeId) -> TyExpression {
+    TyExpression {
+        expression: TyExpressionVariant::IntrinsicFunction(TyIntrinsicFunctionKind {
+            kind: sway_ast::Intrinsic::Revert,
+            arguments: vec![TyExpression {
+                expression: TyExpressionVariant::Literal(crate::language::Literal::U64(17)),
+                return_type: u64_type_id,
+                span: Span::dummy(),
+            }],
+            type_arguments: vec![],
+            span: Span::dummy(),
+        }),
+        return_type: never_type_id,
+        span: Span::dummy(),
+    }
+}
 
 impl ty::TyMatchExpression {
     pub(crate) fn type_check(
@@ -58,7 +91,7 @@ impl ty::TyMatchExpression {
         Ok((typed_exp, typed_scrutinees))
     }
 
-    pub(crate) fn convert_to_typed_if_expression(
+    pub(crate) fn desugar(
         self,
         handler: &Handler,
         ctx: TypeCheckContext,
@@ -76,14 +109,490 @@ impl ty::TyMatchExpression {
             );
         }
 
-        let typed_if_exp = handler.scope(|handler| {
-            self.convert_to_typed_if_expression_inner(instantiate, ctx, handler)
-        })?;
+        let typed_if_exp =
+            handler.scope(
+                |handler| match &*ctx.engines().te().get(self.value_type_id) {
+                    TypeInfo::StringSlice => self.desugar_to_radix_trie(ctx),
+                    _ => self.desugar_to_typed_if_expression(instantiate, ctx, handler),
+                },
+            )?;
 
         Ok(typed_if_exp)
     }
 
-    fn convert_to_typed_if_expression_inner(
+    fn desugar_to_radix_trie(
+        &self,
+        mut ctx: TypeCheckContext<'_>,
+    ) -> Result<TyExpression, ErrorEmitted> {
+        let never_type_id = ctx.engines.te().insert(ctx.engines, TypeInfo::Never, None);
+
+        let u64_type_id = ctx.engines.te().insert(
+            ctx.engines,
+            TypeInfo::UnsignedInteger(sway_types::integer_bits::IntegerBits::SixtyFour),
+            None,
+        );
+
+        let bool_type_id = ctx
+            .engines
+            .te()
+            .insert(ctx.engines, TypeInfo::Boolean, None);
+
+        let branch_return_type_id = self
+            .branches
+            .iter()
+            .map(|x| x.result.return_type)
+            .next()
+            .unwrap();
+
+        let matched_value = self
+            .branches
+            .iter()
+            .flat_map(|x| match &x.condition.as_ref().map(|x| &x.expression) {
+                Some(TyExpressionVariant::FunctionApplication { arguments, .. }) => {
+                    Some(&arguments[0].1)
+                }
+                _ => None,
+            })
+            .next()
+            .unwrap();
+
+        // the block for the wildcard arm
+        let wildcard_return_expr = self
+            .branches
+            .iter()
+            .filter(|x| x.condition.is_none())
+            .map(|x| x.result.clone())
+            .next()
+            .unwrap_or_else(|| revert(never_type_id, u64_type_id));
+
+        // All the match string slices, ignoring the wildcard
+        let match_arms_string_slices = self
+            .branches
+            .iter()
+            .flat_map(|x| match &x.condition.as_ref().map(|x| &x.expression) {
+                Some(TyExpressionVariant::FunctionApplication { arguments, .. }) => {
+                    match &arguments[1].1.expression {
+                        TyExpressionVariant::Literal(crate::language::Literal::String(v)) => {
+                            Some(v.as_str().to_string())
+                        }
+                        _ => None,
+                    }
+                }
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        // group match arms by size of the arm string slice
+        let match_arms_by_size = match_arms_string_slices.iter().enumerate().fold(
+            BTreeMap::<usize, Vec<(String, usize)>>::new(),
+            |mut map, (i, item)| {
+                map.entry(item.len()).or_default().push((item.clone(), i));
+                map
+            },
+        );
+
+        // create and compress all tries. One per arm size
+        let tries = match_arms_by_size
+            .values()
+            .map(|branches| self.generate_radix_trie(branches).unwrap())
+            .collect::<Vec<Trie>>();
+
+        // Navigate all valid nodes and collect string pieces.
+        // Then pack them starting from the biggest.
+        let mut string_pieces = tries
+            .iter()
+            .flat_map(|x| x.nodes.iter())
+            .flat_map(|x| x.next.keys().cloned())
+            .collect::<Vec<String>>();
+        string_pieces.sort_by(|l, r| l.len().cmp(&r.len()).reverse());
+        let packed_strings = string_pieces
+            .into_iter()
+            .fold(String::new(), |mut pack, item| {
+                if !pack.contains(&item) {
+                    pack.push_str(&item);
+                }
+                pack
+            });
+
+        if RADIX_TREE_DEBUG {
+            println!("let packed_string = {packed_strings:?}");
+        }
+
+        // Now create the outer expression checking the size of the string slice
+        let mut block = wildcard_return_expr.clone();
+
+        for ((k, _), trie) in match_arms_by_size.into_iter().zip(tries.into_iter()) {
+            if RADIX_TREE_DEBUG {
+                println!("if str.len() == {k}");
+            }
+
+            let expression = TyExpressionVariant::AsmExpression {
+                registers: vec![
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("is_eq".into()),
+                        initializer: None,
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("slice".into()),
+                        initializer: Some(matched_value.clone()),
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("len".into()),
+                        initializer: None,
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("expected_len".into()),
+                        initializer: Some(TyExpression {
+                            expression: TyExpressionVariant::Literal(
+                                crate::language::Literal::U64(k as u64),
+                            ),
+                            return_type: u64_type_id,
+                            span: Span::dummy(),
+                        }),
+                    },
+                ],
+                body: vec![
+                    AsmOp {
+                        op_name: Ident::new_no_span("lw".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("len".into()),
+                            BaseIdent::new_no_span("slice".into()),
+                        ],
+                        immediate: Some(BaseIdent::new_no_span("i1".into())),
+                        span: Span::dummy(),
+                    },
+                    AsmOp {
+                        op_name: Ident::new_no_span("eq".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("is_eq".into()),
+                            BaseIdent::new_no_span("len".into()),
+                            BaseIdent::new_no_span("expected_len".into()),
+                        ],
+                        immediate: None,
+                        span: Span::dummy(),
+                    },
+                ],
+                returns: Some((
+                    AsmRegister {
+                        name: "is_eq".into(),
+                    },
+                    Span::dummy(),
+                )),
+                whole_block_span: self.span.clone(),
+            };
+
+            let then_node = self
+                .generate_radix_tree_checks(
+                    ctx.by_ref(),
+                    matched_value,
+                    u64_type_id,
+                    branch_return_type_id,
+                    wildcard_return_expr.clone(),
+                    trie,
+                    &packed_strings,
+                )
+                .unwrap();
+
+            block = TyExpression {
+                expression: TyExpressionVariant::IfExp {
+                    condition: Box::new(TyExpression {
+                        expression,
+                        return_type: bool_type_id,
+                        span: self.span.clone(),
+                    }),
+                    then: Box::new(then_node),
+                    r#else: Some(Box::new(block)),
+                },
+                return_type: branch_return_type_id,
+                span: self.span.clone(),
+            };
+        }
+
+        if RADIX_TREE_DEBUG {
+            println!("return wildcard branch");
+        }
+
+        Ok(block)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn generate_radix_trie(&self, branches: &[(String, usize)]) -> Result<Trie, ErrorEmitted> {
+        let mut nodes = vec![TrieNode::default()];
+
+        for (b, i) in branches.iter() {
+            let mut current = 0;
+            for c in b.chars() {
+                let c = c.to_string();
+                if let Some(next) = nodes[current].next.get(&c) {
+                    current = *next;
+                    continue;
+                }
+
+                let next = nodes.len();
+                nodes[current].next.insert(c, next);
+                current = next;
+                nodes.push(TrieNode::default());
+            }
+
+            nodes[current].output = Some(*i);
+        }
+
+        // compress trie
+        let mut q = vec![0];
+        while let Some(i) = q.pop() {
+            let mut current = nodes[i].clone();
+            if current.next.len() == 1 {
+                let edge = current.next.pop_first().unwrap();
+                let mut next = nodes[edge.1].clone();
+                if next.next.len() == 1 {
+                    let next_edge = next.next.pop_first().unwrap();
+                    let compressed_key = format!("{}{}", edge.0, next_edge.0);
+
+                    nodes[i].next.clear();
+                    nodes[i].next.insert(compressed_key, next_edge.1);
+                    nodes[i].output = next.output.take();
+
+                    q.push(i);
+                } else {
+                    nodes[edge.1].previous = Some(i);
+                    q.push(edge.1);
+                }
+            } else {
+                for (_, v) in current.next.iter() {
+                    nodes[*v].previous = Some(i);
+                    q.push(*v);
+                }
+            }
+        }
+
+        Ok(Trie { nodes })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn generate_radix_tree_checks(
+        &self,
+        ctx: TypeCheckContext<'_>,
+        matched_value: &TyExpression,
+        u64_type_id: TypeId,
+        branch_return_type_id: TypeId,
+        wildcard_return_expr: TyExpression,
+        trie: Trie,
+        packed_strings: &str,
+    ) -> Result<TyExpression, ErrorEmitted> {
+        //generate code
+        let bool_type_id = ctx
+            .engines
+            .te()
+            .insert(ctx.engines, TypeInfo::Boolean, None);
+
+        let string_slice_type_id =
+            ctx.engines
+                .te()
+                .insert(ctx.engines, TypeInfo::StringSlice, None);
+
+        let packed_strings_expr = TyExpression {
+            expression: TyExpressionVariant::Literal(crate::language::Literal::String(
+                Span::from_string(packed_strings.to_string()),
+            )),
+            return_type: string_slice_type_id,
+            span: Span::dummy(),
+        };
+
+        let expr = self.generate_radrix_trie_code(
+            matched_value,
+            packed_strings,
+            &packed_strings_expr,
+            &trie.nodes,
+            0,
+            0,
+            bool_type_id,
+            u64_type_id,
+            branch_return_type_id,
+            1,
+            wildcard_return_expr,
+        );
+
+        Ok(expr)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn generate_radrix_trie_code(
+        &self,
+        matched_value: &TyExpression,
+        packed_strings: &str,
+        packed_strings_expr: &TyExpression,
+        nodes: &[TrieNode],
+        slice_pos: usize,
+        current_node_index: usize,
+        bool_type_id: TypeId,
+        u64_type_id: TypeId,
+        branch_return_type_id: TypeId,
+        depth: usize,
+        block_when_all_fail: TyExpression,
+    ) -> TyExpression {
+        let current = &nodes[current_node_index];
+
+        if let Some(output) = current.output {
+            assert!(current.next.is_empty());
+
+            if RADIX_TREE_DEBUG {
+                println!("{}return branch {:?}", " ".repeat(depth * 4), output);
+            }
+
+            let branch = &self.branches[output];
+            return branch.result.clone();
+        }
+
+        let mut block = block_when_all_fail.clone();
+
+        for (prefix, next_node_index) in current.next.iter().rev() {
+            let start = current_node_index;
+            let end = current_node_index + prefix.len();
+            let eq_len: u64 = end as u64 - start as u64;
+
+            let prefix_pos = packed_strings
+                .find(prefix)
+                .expect("prefix should be inside this string");
+
+            if RADIX_TREE_DEBUG {
+                println!(
+                    "{}if str[{start}..{end}] == \"{prefix}\" at packed_string[{prefix_pos}]",
+                    " ".repeat(depth * 4),
+                );
+            }
+
+            let then_node = self.generate_radrix_trie_code(
+                matched_value,
+                packed_strings,
+                packed_strings_expr,
+                nodes,
+                end,
+                *next_node_index,
+                bool_type_id,
+                u64_type_id,
+                branch_return_type_id,
+                depth + 1,
+                block_when_all_fail.clone(),
+            );
+
+            let prefix_pos = packed_strings
+                .find(prefix)
+                .expect("prefix should be inside this string");
+
+            let expression = TyExpressionVariant::AsmExpression {
+                registers: vec![
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("slice".into()),
+                        initializer: Some(matched_value.clone()),
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("prefix".into()),
+                        initializer: Some(packed_strings_expr.clone()),
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("slice_ptr".into()),
+                        initializer: None,
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("prefix_ptr".into()),
+                        initializer: None,
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("len".into()),
+                        initializer: Some(TyExpression {
+                            expression: TyExpressionVariant::Literal(
+                                crate::language::Literal::U64(eq_len),
+                            ),
+                            return_type: u64_type_id,
+                            span: Span::dummy(),
+                        }),
+                    },
+                    TyAsmRegisterDeclaration {
+                        name: Ident::new_no_span("is_eq".into()),
+                        initializer: None,
+                    },
+                ],
+                body: vec![
+                    AsmOp {
+                        op_name: Ident::new_no_span("lw".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("slice_ptr".into()),
+                            BaseIdent::new_no_span("slice".into()),
+                        ],
+                        immediate: Some(BaseIdent::new_no_span("i0".into())),
+                        span: Span::dummy(),
+                    },
+                    AsmOp {
+                        op_name: Ident::new_no_span("addi".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("slice_ptr".into()),
+                            BaseIdent::new_no_span("slice_ptr".into()),
+                        ],
+                        immediate: Some(BaseIdent::new_no_span(format!("i{}", slice_pos))),
+                        span: Span::dummy(),
+                    },
+                    AsmOp {
+                        op_name: Ident::new_no_span("lw".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("prefix_ptr".into()),
+                            BaseIdent::new_no_span("prefix".into()),
+                        ],
+                        immediate: Some(BaseIdent::new_no_span("i0".into())),
+                        span: Span::dummy(),
+                    },
+                    AsmOp {
+                        op_name: Ident::new_no_span("addi".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("prefix_ptr".into()),
+                            BaseIdent::new_no_span("prefix_ptr".into()),
+                        ],
+                        immediate: Some(BaseIdent::new_no_span(format!("i{}", prefix_pos))),
+                        span: Span::dummy(),
+                    },
+                    AsmOp {
+                        op_name: Ident::new_no_span("meq".into()),
+                        op_args: vec![
+                            BaseIdent::new_no_span("is_eq".into()),
+                            BaseIdent::new_no_span("slice_ptr".into()),
+                            BaseIdent::new_no_span("prefix_ptr".into()),
+                            BaseIdent::new_no_span("len".into()),
+                        ],
+                        immediate: None,
+                        span: Span::dummy(),
+                    },
+                ],
+                returns: Some((
+                    AsmRegister {
+                        name: "is_eq".into(),
+                    },
+                    Span::dummy(),
+                )),
+                whole_block_span: Span::dummy(),
+            };
+
+            block = TyExpression {
+                expression: TyExpressionVariant::IfExp {
+                    condition: Box::new(TyExpression {
+                        expression,
+                        return_type: bool_type_id,
+                        span: Span::dummy(),
+                    }),
+                    then: Box::new(then_node),
+                    r#else: Some(Box::new(block)),
+                },
+                return_type: branch_return_type_id,
+                span: Span::dummy(),
+            };
+        }
+
+        if RADIX_TREE_DEBUG {
+            println!("{}return wildcard branch", " ".repeat(depth * 4),);
+        }
+
+        block
+    }
+
+    fn desugar_to_typed_if_expression(
         &self,
         instantiate: Instantiate,
         mut ctx: TypeCheckContext<'_>,
@@ -98,10 +607,12 @@ impl ty::TyMatchExpression {
             matched_or_variant_index_vars,
             condition,
             result,
+            span: branch_span,
             ..
         } in self.branches.iter().rev()
         {
             if let ControlFlow::Break(_) = self.convert_to_typed_if_expression_inner_branch(
+                branch_span.clone(),
                 &mut typed_if_exp,
                 condition,
                 result,
@@ -120,6 +631,7 @@ impl ty::TyMatchExpression {
     #[allow(clippy::too_many_arguments)]
     fn convert_to_typed_if_expression_inner_branch(
         &self,
+        branch_span: Span,
         typed_if_exp: &mut Option<TyExpression>,
         condition: &Option<TyExpression>,
         result: &TyExpression,
@@ -146,7 +658,7 @@ impl ty::TyMatchExpression {
             };
         }
         let ctx = ctx.by_ref().with_type_annotation(self.return_type_id);
-        ctx.scoped(|mut branch_ctx| {
+        ctx.scoped(handler, Some(branch_span), |mut branch_ctx| {
             let result_span = result.span.clone();
             let condition = condition
                 .clone()
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs
index f8b06853ac1..fddb0ee7b21 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs
@@ -6,16 +6,13 @@ use sway_error::{
 use sway_types::{BaseIdent, Ident, Span, Spanned};
 
 use crate::{
-    decl_engine::DeclEngineInsert,
+    decl_engine::{DeclEngineGetParsedDeclId, DeclEngineInsert},
     language::{
         parsed::*,
         ty::{self, StructAccessInfo, TyDecl, TyScrutinee, TyStructDecl, TyStructField},
         CallPath,
     },
-    semantic_analysis::{
-        type_check_context::EnforceTypeArguments, TypeCheckContext, TypeCheckFinalization,
-        TypeCheckFinalizationContext,
-    },
+    semantic_analysis::{TypeCheckContext, TypeCheckFinalization, TypeCheckFinalizationContext},
     type_system::*,
 };
 
@@ -143,7 +140,6 @@ impl TyScrutinee {
             ty::TyScrutineeVariant::Variable(_) => true,
             ty::TyScrutineeVariant::Literal(_) => false,
             ty::TyScrutineeVariant::Constant { .. } => false,
-            ty::TyScrutineeVariant::Configurable { .. } => false,
             ty::TyScrutineeVariant::StructScrutinee { fields, .. } => fields
                 .iter()
                 .filter_map(|x| x.scrutinee.as_ref())
@@ -155,6 +151,8 @@ impl TyScrutinee {
     }
 }
 
+/// Type checks the `name`, assuming that it's either a variable or an ambiguous identifier
+/// that might be a constant or configurable.
 fn type_check_variable(
     handler: &Handler,
     ctx: TypeCheckContext,
@@ -170,14 +168,14 @@ fn type_check_variable(
         .resolve_symbol_typed(&Handler::default(), engines, &name, ctx.self_type())
         .ok()
     {
-        // If this variable is a constant, then we turn it into a [TyScrutinee::Constant](ty::TyScrutinee::Constant).
+        // If the name represents a constant, then we turn it into a [ty::TyScrutineeVariant::Constant].
         Some(ty::TyDecl::ConstantDecl(ty::ConstantDecl { decl_id, .. })) => {
             let constant_decl = (*decl_engine.get_constant(&decl_id)).clone();
             let value = match constant_decl.value {
                 Some(ref value) => value,
                 None => {
                     return Err(handler.emit_err(CompileError::Internal(
-                        "constant value does not contain expression",
+                        "Constant value does not contain expression",
                         span,
                     )));
                 }
@@ -198,7 +196,15 @@ fn type_check_variable(
                 span,
             }
         }
-        // Variable isn't a constant, so we turn it into a [ty::TyScrutinee::Variable].
+        // If the name isn't a constant, we turn it into a [ty::TyScrutineeVariant::Variable].
+        //
+        // Note that the declaration could be a configurable declaration, [ty::ConfigurableDecl].
+        // Configurables cannot be matched against, but we do not emit that error here.
+        // That would unnecessary short-circuit the compilation and reduce number of errors
+        // collected.
+        // Rather, we consider the configurable to be a pattern variable declaration, which
+        // strictly speaking it is. Later when checking typed match arm, we will emit
+        // appropriate helpful errors, depending on the exact usage of that configurable.
         _ => ty::TyScrutinee {
             variant: ty::TyScrutineeVariant::Variable(name),
             type_id: type_engine.insert(ctx.engines(), TypeInfo::Unknown, None),
@@ -224,8 +230,8 @@ fn type_check_struct(
     let unknown_decl =
         ctx.namespace()
             .resolve_symbol_typed(handler, engines, &struct_name, ctx.self_type())?;
-    let struct_ref = unknown_decl.to_struct_ref(handler, ctx.engines())?;
-    let mut struct_decl = (*decl_engine.get_struct(&struct_ref)).clone();
+    let struct_id = unknown_decl.to_struct_decl(handler, ctx.engines())?;
+    let mut struct_decl = (*decl_engine.get_struct(&struct_id)).clone();
 
     // monomorphize the struct definition
     ctx.monomorphize(
@@ -414,11 +420,14 @@ fn type_check_struct(
         Ok(())
     })?;
 
-    let struct_ref = decl_engine.insert(struct_decl);
+    let struct_ref = decl_engine.insert(
+        struct_decl,
+        decl_engine.get_parsed_decl_id(&struct_id).as_ref(),
+    );
     let typed_scrutinee = ty::TyScrutinee {
         type_id: type_engine.insert(
             ctx.engines(),
-            TypeInfo::Struct(struct_ref.clone()),
+            TypeInfo::Struct(*struct_ref.id()),
             struct_ref.span().source_id(),
         ),
         span,
@@ -479,7 +488,7 @@ fn type_check_enum(
     let engines = ctx.engines();
 
     let mut prefixes = call_path.prefixes.clone();
-    let (callsite_span, mut enum_decl, call_path_decl) = match prefixes.pop() {
+    let (callsite_span, enum_id, call_path_decl) = match prefixes.pop() {
         Some(enum_name) => {
             let enum_callpath = CallPath {
                 suffix: enum_name,
@@ -493,12 +502,8 @@ fn type_check_enum(
                 &enum_callpath,
                 ctx.self_type(),
             )?;
-            let enum_ref = unknown_decl.to_enum_ref(handler, ctx.engines())?;
-            (
-                enum_callpath.span(),
-                (*decl_engine.get_enum(&enum_ref)).clone(),
-                unknown_decl,
-            )
+            let enum_id = unknown_decl.to_enum_id(handler, ctx.engines())?;
+            (enum_callpath.span(), enum_id, unknown_decl)
         }
         None => {
             // we may have an imported variant
@@ -509,11 +514,7 @@ fn type_check_enum(
                 ctx.self_type(),
             )?;
             if let TyDecl::EnumVariantDecl(ty::EnumVariantDecl { enum_ref, .. }) = decl.clone() {
-                (
-                    call_path.suffix.span(),
-                    (*decl_engine.get_enum(enum_ref.id())).clone(),
-                    decl,
-                )
+                (call_path.suffix.span(), *enum_ref.id(), decl)
             } else {
                 return Err(handler.emit_err(CompileError::EnumNotFound {
                     name: call_path.suffix.clone(),
@@ -522,6 +523,7 @@ fn type_check_enum(
             }
         }
     };
+    let mut enum_decl = (*decl_engine.get_enum(&enum_id)).clone();
     let variant_name = call_path.suffix.clone();
 
     // monomorphize the enum definition
@@ -541,7 +543,7 @@ fn type_check_enum(
     // type check the nested scrutinee
     let typed_value = ty::TyScrutinee::type_check(handler, ctx, value)?;
 
-    let enum_ref = decl_engine.insert(enum_decl);
+    let enum_ref = decl_engine.insert(enum_decl, decl_engine.get_parsed_decl_id(&enum_id).as_ref());
     let typed_scrutinee = ty::TyScrutinee {
         variant: ty::TyScrutineeVariant::EnumScrutinee {
             enum_ref: enum_ref.clone(),
@@ -552,7 +554,7 @@ fn type_check_enum(
         },
         type_id: type_engine.insert(
             engines,
-            TypeInfo::Enum(enum_ref.clone()),
+            TypeInfo::Enum(*enum_ref.id()),
             enum_ref.span().source_id(),
         ),
         span,
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
index 66ced92f16d..af790c3d2ed 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
@@ -29,7 +29,7 @@ use crate::{
         *,
     },
     namespace::{IsExtendingExistingImpl, IsImplSelf},
-    semantic_analysis::{expression::ReachableReport, type_check_context::EnforceTypeArguments, *},
+    semantic_analysis::{expression::ReachableReport, *},
     transform::to_parsed_lang::type_name_to_type_info_opt,
     type_system::*,
     Engines,
@@ -48,6 +48,7 @@ use sway_error::{
     warning::{CompileWarning, Warning},
 };
 use sway_types::{integer_bits::IntegerBits, u256::U256, Ident, Named, Span, Spanned};
+use symbol_collection_context::SymbolCollectionContext;
 
 #[allow(clippy::too_many_arguments)]
 impl ty::TyExpression {
@@ -128,7 +129,6 @@ impl ty::TyExpression {
                 selector: None,
                 type_binding: None,
                 call_path_typeid: None,
-                deferred_monomorphization: false,
                 contract_call_params: IndexMap::new(),
                 contract_caller: None,
             },
@@ -138,6 +138,143 @@ impl ty::TyExpression {
         Ok(exp)
     }
 
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        expr: &Expression,
+    ) -> Result<(), ErrorEmitted> {
+        match &expr.kind {
+            ExpressionKind::Error(_, _) => {}
+            ExpressionKind::Literal(_) => {}
+            ExpressionKind::AmbiguousPathExpression(expr) => {
+                expr.args
+                    .iter()
+                    .map(|arg_expr| Self::collect(handler, engines, ctx, arg_expr))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::FunctionApplication(expr) => {
+                expr.arguments
+                    .iter()
+                    .map(|arg_expr| Self::collect(handler, engines, ctx, arg_expr))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::LazyOperator(expr) => {
+                Self::collect(handler, engines, ctx, &expr.lhs)?;
+                Self::collect(handler, engines, ctx, &expr.rhs)?;
+            }
+            ExpressionKind::AmbiguousVariableExpression(_) => {}
+            ExpressionKind::Variable(_) => {}
+            ExpressionKind::Tuple(exprs) => {
+                exprs
+                    .iter()
+                    .map(|expr| Self::collect(handler, engines, ctx, expr))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::TupleIndex(expr) => {
+                Self::collect(handler, engines, ctx, &expr.prefix)?;
+            }
+            ExpressionKind::Array(expr) => {
+                expr.contents
+                    .iter()
+                    .map(|expr| Self::collect(handler, engines, ctx, expr))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::Struct(expr) => {
+                expr.fields
+                    .iter()
+                    .map(|field| Self::collect(handler, engines, ctx, &field.value))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::CodeBlock(code_block) => {
+                TyCodeBlock::collect(handler, engines, ctx, code_block)?
+            }
+            ExpressionKind::If(if_expr) => {
+                Self::collect(handler, engines, ctx, &if_expr.condition)?;
+                Self::collect(handler, engines, ctx, &if_expr.then)?;
+                if let Some(r#else) = &if_expr.r#else {
+                    Self::collect(handler, engines, ctx, r#else)?
+                }
+            }
+            ExpressionKind::Match(expr) => {
+                Self::collect(handler, engines, ctx, &expr.value)?;
+                expr.branches
+                    .iter()
+                    .map(|branch| {
+                        // create a new namespace for this branch result
+                        ctx.scoped(engines, branch.span.clone(), |scoped_ctx| {
+                            Self::collect(handler, engines, scoped_ctx, &branch.result)
+                        })
+                        .0
+                    })
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::Asm(_) => {}
+            ExpressionKind::MethodApplication(expr) => {
+                expr.arguments
+                    .iter()
+                    .map(|expr| Self::collect(handler, engines, ctx, expr))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::Subfield(expr) => {
+                Self::collect(handler, engines, ctx, &expr.prefix)?;
+            }
+            ExpressionKind::DelineatedPath(expr) => {
+                if let Some(expr_args) = &expr.args {
+                    expr_args
+                        .iter()
+                        .map(|arg_expr| Self::collect(handler, engines, ctx, arg_expr))
+                        .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+                }
+            }
+            ExpressionKind::AbiCast(expr) => {
+                Self::collect(handler, engines, ctx, &expr.address)?;
+            }
+            ExpressionKind::ArrayIndex(expr) => {
+                Self::collect(handler, engines, ctx, &expr.prefix)?;
+                Self::collect(handler, engines, ctx, &expr.index)?;
+            }
+            ExpressionKind::StorageAccess(_) => {}
+            ExpressionKind::IntrinsicFunction(expr) => {
+                expr.arguments
+                    .iter()
+                    .map(|arg_expr| Self::collect(handler, engines, ctx, arg_expr))
+                    .collect::<Result<Vec<_>, ErrorEmitted>>()?;
+            }
+            ExpressionKind::WhileLoop(expr) => {
+                Self::collect(handler, engines, ctx, &expr.condition)?;
+                TyCodeBlock::collect(handler, engines, ctx, &expr.body)?
+            }
+            ExpressionKind::ForLoop(expr) => {
+                Self::collect(handler, engines, ctx, &expr.desugared)?;
+            }
+            ExpressionKind::Break => {}
+            ExpressionKind::Continue => {}
+            ExpressionKind::Reassignment(expr) => {
+                match &expr.lhs {
+                    ReassignmentTarget::ElementAccess(expr) => {
+                        Self::collect(handler, engines, ctx, expr)?;
+                    }
+                    ReassignmentTarget::Deref(expr) => {
+                        Self::collect(handler, engines, ctx, expr)?;
+                    }
+                }
+                Self::collect(handler, engines, ctx, &expr.rhs)?;
+            }
+            ExpressionKind::ImplicitReturn(expr) => Self::collect(handler, engines, ctx, expr)?,
+            ExpressionKind::Return(expr) => {
+                Self::collect(handler, engines, ctx, expr)?;
+            }
+            ExpressionKind::Ref(expr) => {
+                Self::collect(handler, engines, ctx, &expr.value)?;
+            }
+            ExpressionKind::Deref(expr) => {
+                Self::collect(handler, engines, ctx, expr)?;
+            }
+        }
+        Ok(())
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,
@@ -194,6 +331,7 @@ impl ty::TyExpression {
             ExpressionKind::FunctionApplication(function_application_expression) => {
                 let FunctionApplicationExpression {
                     call_path_binding,
+                    resolved_call_path_binding: _,
                     ref arguments,
                 } = *function_application_expression.clone();
                 Self::type_check_function_application(
@@ -635,7 +773,7 @@ impl ty::TyExpression {
         let engines = ctx.engines();
 
         let (typed_block, block_return_type) =
-            match ty::TyCodeBlock::type_check(handler, ctx.by_ref(), contents) {
+            match ty::TyCodeBlock::type_check(handler, ctx.by_ref(), contents, false) {
                 Ok(res) => {
                     let (block_type, _span) = TyCodeBlock::compute_return_type_and_span(&ctx, &res);
                     (res, block_type)
@@ -841,13 +979,13 @@ impl ty::TyExpression {
         }
 
         // desugar the typed match expression to a typed if expression
-        let typed_if_exp = typed_match_expression.convert_to_typed_if_expression(handler, ctx)?;
+        let desugared = typed_match_expression.desugar(handler, ctx)?;
 
         let match_exp = ty::TyExpression {
-            span: typed_if_exp.span.clone(),
-            return_type: typed_if_exp.return_type,
+            span: desugared.span.clone(),
+            return_type: desugared.return_type,
             expression: ty::TyExpressionVariant::MatchExp {
-                desugared: Box::new(typed_if_exp),
+                desugared: Box::new(desugared),
                 scrutinees: typed_scrutinees,
             },
         };
@@ -907,6 +1045,13 @@ impl ty::TyExpression {
         let type_engine = ctx.engines.te();
         let engines = ctx.engines();
 
+        if asm.is_empty() {
+            handler.emit_warn(CompileWarning {
+                span: span.clone(),
+                warning_content: Warning::AsmBlockIsEmpty,
+            });
+        }
+
         // Various checks that we can catch early to check that the assembly is valid. For now,
         // this includes two checks:
         // 1. Check that no control flow opcodes are used.
@@ -1098,19 +1243,19 @@ impl ty::TyExpression {
         let storage_key_ident = Ident::new_with_override("StorageKey".into(), span.clone());
 
         // Search for the struct declaration with the call path above.
-        let storage_key_decl_opt = ctx
-            .namespace()
-            .resolve_root_symbol(
-                handler,
-                engines,
-                &storage_key_mod_path,
-                &storage_key_ident,
-                None,
-            )?
-            .expect_typed();
-        let storage_key_struct_decl_ref = storage_key_decl_opt.to_struct_ref(handler, engines)?;
+        let storage_key_decl = ctx.namespace().root().resolve_symbol(
+            handler,
+            engines,
+            &storage_key_mod_path,
+            &storage_key_ident,
+            None,
+        )?;
+
+        let storage_key_struct_decl_id = storage_key_decl
+            .expect_typed()
+            .to_struct_decl(handler, engines)?;
         let mut storage_key_struct_decl =
-            (*decl_engine.get_struct(&storage_key_struct_decl_ref)).clone();
+            (*decl_engine.get_struct(&storage_key_struct_decl_id)).clone();
 
         // Set the type arguments to `StorageKey` to the `access_type`, which is represents the
         // type of the data that the `StorageKey` "points" to.
@@ -1133,10 +1278,15 @@ impl ty::TyExpression {
 
         // Update `access_type` to be the type of the monomorphized struct after inserting it
         // into the type engine
-        let storage_key_struct_decl_ref = ctx.engines().de().insert(storage_key_struct_decl);
+        let storage_key_struct_decl_ref = decl_engine.insert(
+            storage_key_struct_decl,
+            decl_engine
+                .get_parsed_decl_id(&storage_key_struct_decl_id)
+                .as_ref(),
+        );
         access_type = type_engine.insert(
             engines,
-            TypeInfo::Struct(storage_key_struct_decl_ref.clone()),
+            TypeInfo::Struct(*storage_key_struct_decl_ref.id()),
             storage_key_struct_decl_ref.span().source_id(),
         );
 
@@ -1325,7 +1475,7 @@ impl ty::TyExpression {
                     &probe_call_path,
                     ctx.self_type(),
                 )
-                .and_then(|decl| decl.to_enum_ref(&Handler::default(), ctx.engines()))
+                .and_then(|decl| decl.to_enum_id(&Handler::default(), ctx.engines()))
                 .map(|decl_ref| decl_engine.get_enum(&decl_ref))
                 .and_then(|decl| {
                     decl.expect_variant_from_name(&Handler::default(), &suffix)
@@ -1723,20 +1873,32 @@ impl ty::TyExpression {
                     let method = decl_engine.get_trait_fn(decl_ref);
                     abi_items.push(TyImplItem::Fn(
                         decl_engine
-                            .insert(method.to_dummy_func(
-                                AbiMode::ImplAbiFn(abi_name.suffix.clone(), Some(*abi_ref.id())),
-                                Some(return_type),
-                            ))
+                            .insert(
+                                method.to_dummy_func(
+                                    AbiMode::ImplAbiFn(
+                                        abi_name.suffix.clone(),
+                                        Some(*abi_ref.id()),
+                                    ),
+                                    Some(return_type),
+                                ),
+                                None,
+                            )
                             .with_parent(decl_engine, (*decl_ref.id()).into()),
                     ));
                 }
                 ty::TyTraitInterfaceItem::Constant(decl_ref) => {
                     let const_decl = decl_engine.get_constant(decl_ref);
-                    abi_items.push(TyImplItem::Constant(decl_engine.insert_arc(const_decl)));
+                    abi_items.push(TyImplItem::Constant(decl_engine.insert_arc(
+                        const_decl,
+                        decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                    )));
                 }
                 ty::TyTraitInterfaceItem::Type(decl_ref) => {
                     let type_decl = decl_engine.get_type(decl_ref);
-                    abi_items.push(TyImplItem::Type(decl_engine.insert_arc(type_decl)));
+                    abi_items.push(TyImplItem::Type(decl_engine.insert_arc(
+                        type_decl,
+                        decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                    )));
                 }
             }
         }
@@ -1789,20 +1951,20 @@ impl ty::TyExpression {
         let engines = ctx.engines();
 
         if contents.is_empty() {
-            let never_type = type_engine.insert(engines, TypeInfo::Never, None);
+            let elem_type = type_engine.insert(engines, TypeInfo::Unknown, None);
             return Ok(ty::TyExpression {
                 expression: ty::TyExpressionVariant::Array {
-                    elem_type: never_type,
+                    elem_type,
                     contents: Vec::new(),
                 },
                 return_type: type_engine.insert(
                     engines,
                     TypeInfo::Array(
                         TypeArgument {
-                            type_id: never_type,
+                            type_id: elem_type,
                             span: Span::dummy(),
                             call_path_tree: None,
-                            initial_type_id: never_type,
+                            initial_type_id: elem_type,
                         },
                         Length::new(0, Span::dummy()),
                     ),
@@ -1812,11 +1974,16 @@ impl ty::TyExpression {
             });
         };
 
-        // start each element with the known array element type, or Unknown if it is to be inferred
-        // from the elements
+        // capture the expected array element type from context,
+        // otherwise, fallback to Unknown.
         let initial_type = match &*ctx.engines().te().get(ctx.type_annotation()) {
             TypeInfo::Array(element_type, _) => {
-                (*ctx.engines().te().get(element_type.type_id)).clone()
+                let element_type = (*ctx.engines().te().get(element_type.type_id)).clone();
+                if matches!(element_type, TypeInfo::Never) {
+                    TypeInfo::Unknown //Even if array element type is Never other elements may not be of type Never.
+                } else {
+                    element_type
+                }
             }
             _ => TypeInfo::Unknown,
         };
@@ -1829,15 +1996,38 @@ impl ty::TyExpression {
                     .by_ref()
                     .with_help_text("")
                     .with_type_annotation(type_engine.insert(engines, initial_type.clone(), None));
-                Self::type_check(handler, ctx, expr)
-                    .unwrap_or_else(|err| ty::TyExpression::error(err, span, engines))
+
+                // type_check_analyze unification will give the final error
+                let type_check_handler = Handler::default();
+                let result = Self::type_check(&type_check_handler, ctx, expr)
+                    .unwrap_or_else(|err| ty::TyExpression::error(err, span, engines));
+
+                if let TypeInfo::ErrorRecovery(_) = &*engines.te().get(result.return_type) {
+                    handler.append(type_check_handler);
+                }
+
+                result
             })
             .collect();
 
-        let elem_type = typed_contents[0].return_type;
+        // if the element type is still unknown, and all elements are Never,
+        // fallback to unit
+        let initial_type = if matches!(initial_type, TypeInfo::Unknown) {
+            let is_all_elements_never = typed_contents
+                .iter()
+                .all(|expr| matches!(&*engines.te().get(expr.return_type), TypeInfo::Never));
+            if is_all_elements_never {
+                TypeInfo::Tuple(vec![])
+            } else {
+                initial_type
+            }
+        } else {
+            initial_type
+        };
 
+        let elem_type = type_engine.insert(engines, initial_type.clone(), None);
         let array_count = typed_contents.len();
-        Ok(ty::TyExpression {
+        let expr = ty::TyExpression {
             expression: ty::TyExpressionVariant::Array {
                 elem_type,
                 contents: typed_contents,
@@ -1854,9 +2044,15 @@ impl ty::TyExpression {
                     Length::new(array_count, Span::dummy()),
                 ),
                 None,
-            ), // Maybe?
+            ),
             span,
-        })
+        };
+
+        // type_check_analyze unification will give the final error
+        let handler = Handler::default();
+        expr.as_array_unify_elements(&handler, ctx.engines);
+
+        Ok(expr)
     }
 
     fn type_check_array_index(
@@ -1984,7 +2180,7 @@ impl ty::TyExpression {
                  assigning it to a mutable variable declared outside of the loop \
                  instead.",
         );
-        let typed_body = ty::TyCodeBlock::type_check(handler, ctx.by_ref(), body)?;
+        let typed_body = ty::TyCodeBlock::type_check(handler, ctx.by_ref(), body, false)?;
 
         let exp = ty::TyExpression {
             expression: ty::TyExpressionVariant::WhileLoop {
@@ -2302,26 +2498,13 @@ impl ty::TyExpression {
         let expr = ty::TyExpression::type_check(handler, ctx, value)?;
 
         if to_mutable_value {
-            match expr.expression {
-                ty::TyExpressionVariant::ConstantExpression { .. } => {
-                    return Err(
-                        handler.emit_err(CompileError::RefMutCannotReferenceConstant {
-                            constant: expr_span.str(),
-                            span,
-                        }),
-                    )
-                }
-                ty::TyExpressionVariant::VariableExpression {
-                    name: decl_name,
-                    mutability: VariableMutability::Immutable,
-                    ..
-                } => {
-                    return Err(handler.emit_err(
-                        CompileError::RefMutCannotReferenceImmutableVariable { decl_name, span },
-                    ))
-                }
-                // TODO-IG: Check referencing parts of aggregates once reassignment is implemented.
-                _ => (),
+            if let Some(value) = Self::check_ref_mutability_mismatch(
+                &expr.expression,
+                handler,
+                expr_span,
+                span.clone(),
+            ) {
+                return value;
             }
         };
 
@@ -2342,6 +2525,54 @@ impl ty::TyExpression {
         Ok(typed_expr)
     }
 
+    fn check_ref_mutability_mismatch(
+        expr: &TyExpressionVariant,
+        handler: &Handler,
+        expr_span: Span,
+        ref_span: Span,
+    ) -> Option<Result<TyExpression, ErrorEmitted>> {
+        match expr {
+            ty::TyExpressionVariant::ConstantExpression { .. } => {
+                return Some(Err(handler.emit_err(
+                    CompileError::RefMutCannotReferenceConstant {
+                        constant: expr_span.str(),
+                        span: ref_span,
+                    },
+                )))
+            }
+            ty::TyExpressionVariant::VariableExpression {
+                name: decl_name,
+                mutability: VariableMutability::Immutable,
+                ..
+            } => {
+                return Some(Err(handler.emit_err(
+                    CompileError::RefMutCannotReferenceImmutableVariable {
+                        decl_name: decl_name.clone(),
+                        span: ref_span,
+                    },
+                )))
+            }
+            ty::TyExpressionVariant::StructFieldAccess { ref prefix, .. } => {
+                return Self::check_ref_mutability_mismatch(
+                    &prefix.expression,
+                    handler,
+                    expr_span,
+                    ref_span,
+                )
+            }
+            ty::TyExpressionVariant::TupleElemAccess { ref prefix, .. } => {
+                return Self::check_ref_mutability_mismatch(
+                    &prefix.expression,
+                    handler,
+                    expr_span,
+                    ref_span,
+                )
+            }
+            _ => (),
+        }
+        None
+    }
+
     fn type_check_deref(
         handler: &Handler,
         mut ctx: TypeCheckContext<'_>,
@@ -2600,7 +2831,7 @@ fn check_asm_block_validity(
             if reg.initializer.is_none() {
                 let span = reg.name.span();
 
-                // Emit warning if this register shadows a variable
+                // Emit warning if this register shadows a constant, or a configurable, or a variable.
                 let temp_handler = Handler::default();
                 let decl = ctx.namespace().resolve_call_path_typed(
                     &temp_handler,
@@ -2613,11 +2844,25 @@ fn check_asm_block_validity(
                     None,
                 );
 
-                if let Ok(ty::TyDecl::VariableDecl(decl)) = decl {
+                let shadowing_item = match decl {
+                    Ok(ty::TyDecl::ConstantDecl(decl)) => {
+                        let decl = ctx.engines.de().get_constant(&decl.decl_id);
+                        Some((decl.name().into(), "Constant"))
+                    }
+                    Ok(ty::TyDecl::ConfigurableDecl(decl)) => {
+                        let decl = ctx.engines.de().get_configurable(&decl.decl_id);
+                        Some((decl.name().into(), "Configurable"))
+                    }
+                    Ok(ty::TyDecl::VariableDecl(decl)) => Some((decl.name.into(), "Variable")),
+                    _ => None,
+                };
+
+                if let Some((item, item_kind)) = shadowing_item {
                     handler.emit_warn(CompileWarning {
                         span: span.clone(),
-                        warning_content: Warning::UninitializedAsmRegShadowsVariable {
-                            name: decl.name.clone(),
+                        warning_content: Warning::UninitializedAsmRegShadowsItem {
+                            constant_or_configurable_or_variable: item_kind,
+                            item,
                         },
                     });
                 }
@@ -2656,6 +2901,7 @@ mod tests {
     use super::*;
     use crate::{Engines, ExperimentalFlags};
     use sway_error::type_error::TypeError;
+    use symbol_collection_context::SymbolCollectionContext;
 
     fn do_type_check(
         handler: &Handler,
@@ -2664,10 +2910,23 @@ mod tests {
         type_annotation: TypeId,
         experimental: ExperimentalFlags,
     ) -> Result<ty::TyExpression, ErrorEmitted> {
-        let root_module = namespace::Root::from(namespace::Module::default());
-        let mut namespace = Namespace::init_root(root_module);
-        let ctx = TypeCheckContext::from_namespace(&mut namespace, engines, experimental)
-            .with_type_annotation(type_annotation);
+        let collection_ctx_ns = Namespace::new();
+        let mut collection_ctx = SymbolCollectionContext::new(collection_ctx_ns);
+
+        let root_module_name = sway_types::Ident::new_no_span("do_type_check_test".to_string());
+        let mut root_module = namespace::Root::from(namespace::Module::new(
+            root_module_name,
+            Visibility::Private,
+            None,
+        ));
+        let mut namespace = Namespace::init_root(&mut root_module);
+        let ctx = TypeCheckContext::from_namespace(
+            &mut namespace,
+            &mut collection_ctx,
+            engines,
+            experimental,
+        )
+        .with_type_annotation(type_annotation);
         ty::TyExpression::type_check(handler, ctx, expr)
     }
 
@@ -2676,7 +2935,7 @@ mod tests {
         expr: &Expression,
     ) -> Result<ty::TyExpression, ErrorEmitted> {
         let engines = Engines::default();
-        do_type_check(
+        let expr = do_type_check(
             handler,
             &engines,
             expr,
@@ -2696,7 +2955,9 @@ mod tests {
             ExperimentalFlags {
                 new_encoding: false,
             },
-        )
+        )?;
+        expr.type_check_analyze(handler, &mut TypeCheckAnalysisContext::new(&engines))?;
+        Ok(expr)
     }
 
     #[test]
@@ -2723,7 +2984,7 @@ mod tests {
         let _comp_res = do_type_check_for_boolx2(&handler, &expr);
         let (errors, _warnings) = handler.consume();
 
-        assert!(errors.len() == 1);
+        assert_eq!(errors.len(), 1);
         assert!(matches!(&errors[0],
                          CompileError::TypeError(TypeError::MismatchedType {
                              expected,
@@ -2757,7 +3018,7 @@ mod tests {
         let _comp_res = do_type_check_for_boolx2(&handler, &expr);
         let (errors, _warnings) = handler.consume();
 
-        assert!(errors.len() == 2);
+        assert!(errors.len() == 1);
         assert!(matches!(&errors[0],
                          CompileError::TypeError(TypeError::MismatchedType {
                              expected,
@@ -2765,13 +3026,6 @@ mod tests {
                              ..
                          }) if expected == "bool"
                                 && received == "u64"));
-        assert!(matches!(&errors[1],
-                         CompileError::TypeError(TypeError::MismatchedType {
-                             expected,
-                             received,
-                             ..
-                         }) if expected == "[bool; 2]"
-                                && received == "[u64; 2]"));
     }
 
     #[test]
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/enum_instantiation.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/enum_instantiation.rs
index e1e944f8633..35ddcb183ca 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/enum_instantiation.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/enum_instantiation.rs
@@ -58,7 +58,7 @@ pub(crate) fn instantiate_enum(
         ([], ty) if ty.is_unit() => Ok(ty::TyExpression {
             return_type: type_engine.insert(
                 engines,
-                TypeInfo::Enum(enum_ref.clone()),
+                TypeInfo::Enum(*enum_ref.id()),
                 enum_ref.span().source_id(),
             ),
             expression: ty::TyExpressionVariant::EnumInstantiation {
@@ -108,7 +108,7 @@ pub(crate) fn instantiate_enum(
             let (is_context_type_used, enum_variant_type_id, help_text) =
                 match &*type_engine.get(context_expected_type_id) {
                     TypeInfo::Enum(e) => {
-                        let context_expected_enum_decl = decl_engine.get_enum(e.id());
+                        let context_expected_enum_decl = decl_engine.get_enum(e);
                         if UnifyCheck::coercion(engines)
                             .check_enums(&context_expected_enum_decl, &enum_decl)
                         {
@@ -151,7 +151,7 @@ pub(crate) fn instantiate_enum(
             // affect the types behind that new enum decl reference.
             let type_id = type_engine.insert(
                 engines,
-                TypeInfo::Enum(enum_ref.clone()),
+                TypeInfo::Enum(*enum_ref.id()),
                 enum_ref.span().source_id(),
             );
 
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs
index ba2d01049e9..b3bfdbcf7ca 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs
@@ -1,5 +1,7 @@
 use crate::{
-    decl_engine::{DeclEngineInsert, DeclRefFunction, ReplaceDecls},
+    decl_engine::{
+        engine::DeclEngineGetParsedDeclId, DeclEngineInsert, DeclRefFunction, ReplaceDecls,
+    },
     language::{
         ty::{self, TyFunctionSig},
         *,
@@ -37,15 +39,8 @@ pub(crate) fn instantiate_function_application(
             }),
         );
     }
-    let arguments = arguments.unwrap_or_default();
 
-    // 'purity' is that of the callee, 'opts.purity' of the caller.
-    if !ctx.purity().can_call(function_decl.purity) {
-        handler.emit_err(CompileError::StorageAccessMismatch {
-            attrs: promote_purity(ctx.purity(), function_decl.purity).to_attribute_syntax(),
-            span: call_path_binding.span(),
-        });
-    }
+    let arguments = arguments.unwrap_or_default();
 
     // check that the number of parameters and the number of the arguments is the same
     check_function_arguments_arity(
@@ -66,6 +61,17 @@ pub(crate) fn instantiate_function_application(
         &function_decl.parameters,
     )?;
 
+    // unify function return type with current ctx.type_annotation().
+    engines.te().unify_with_generic(
+        handler,
+        engines,
+        function_decl.return_type.type_id,
+        ctx.type_annotation(),
+        &call_path_binding.span(),
+        "Function return type does not match up with local type annotation.",
+        None,
+    );
+
     let mut function_return_type_id = function_decl.return_type.type_id;
 
     let function_ident: IdentUnique = function_decl.name.clone().into();
@@ -78,18 +84,20 @@ pub(crate) fn instantiate_function_application(
     {
         cached_fn_ref
     } else {
-        // Handle the trait constraints. This includes checking to see if the trait
-        // constraints are satisfied and replacing old decl ids based on the
-        // constraint with new decl ids based on the new type.
-        let decl_mapping = TypeParameter::gather_decl_mapping_from_trait_constraints(
-            handler,
-            ctx.by_ref(),
-            &function_decl.type_parameters,
-            function_decl.name.as_str(),
-            &call_path_binding.span(),
-        )?;
-
-        function_decl.replace_decls(&decl_mapping, handler, &mut ctx)?;
+        if !ctx.code_block_first_pass() {
+            // Handle the trait constraints. This includes checking to see if the trait
+            // constraints are satisfied and replacing old decl ids based on the
+            // constraint with new decl ids based on the new type.
+            let decl_mapping = TypeParameter::gather_decl_mapping_from_trait_constraints(
+                handler,
+                ctx.by_ref(),
+                &function_decl.type_parameters,
+                function_decl.name.as_str(),
+                &call_path_binding.span(),
+            )?;
+
+            function_decl.replace_decls(&decl_mapping, handler, &mut ctx)?;
+        }
 
         let method_sig = TyFunctionSig::from_fn_decl(&function_decl);
 
@@ -97,10 +105,16 @@ pub(crate) fn instantiate_function_application(
         let function_is_type_check_finalized = function_decl.is_type_check_finalized;
         let function_is_trait_method_dummy = function_decl.is_trait_method_dummy;
         let new_decl_ref = decl_engine
-            .insert(function_decl)
+            .insert(
+                function_decl,
+                decl_engine
+                    .get_parsed_decl_id(function_decl_ref.id())
+                    .as_ref(),
+            )
             .with_parent(decl_engine, (*function_decl_ref.id()).into());
 
-        if method_sig.is_concrete(engines)
+        if !ctx.code_block_first_pass()
+            && method_sig.is_concrete(engines)
             && function_is_type_check_finalized
             && !function_is_trait_method_dummy
         {
@@ -123,7 +137,6 @@ pub(crate) fn instantiate_function_application(
             selector: None,
             type_binding: Some(call_path_binding.strip_inner()),
             call_path_typeid: None,
-            deferred_monomorphization: false,
             contract_call_params: IndexMap::new(),
             contract_caller: None,
         },
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/if_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/if_expression.rs
index fd9cb084665..bdd3679c869 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/if_expression.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/if_expression.rs
@@ -80,7 +80,6 @@ pub(crate) fn instantiate_if_expression(
             help_text: "The two branches of an if expression must return the same type."
                 .to_string(),
             span: span.clone(),
-            internal: "".into(),
         }));
     }
 
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs
index c25a631b328..2619ab21664 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs
@@ -1,6 +1,6 @@
 use crate::{
     decl_engine::{
-        engine::{DeclEngineGet, DeclEngineReplace},
+        engine::{DeclEngineGet, DeclEngineGetParsedDeclId, DeclEngineReplace},
         DeclEngineInsert, DeclRefFunction, ReplaceDecls, UpdateConstantExpression,
     },
     language::{
@@ -9,7 +9,7 @@ use crate::{
         *,
     },
     namespace::TryInsertingTraitImplOnFailure,
-    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
+    semantic_analysis::*,
     type_system::*,
 };
 use ast_node::typed_expression::check_function_arguments_arity;
@@ -46,11 +46,14 @@ pub(crate) fn type_check_method_application(
             .by_ref()
             .with_help_text("")
             .with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None));
+
         // Ignore errors in method parameters
         // On the second pass we will throw the errors if they persist.
         let arg_handler = Handler::default();
         let arg_opt = ty::TyExpression::type_check(&arg_handler, ctx, arg).ok();
-        let has_errors = arg_handler.has_errors();
+
+        let needs_second_pass = arg_handler.has_errors();
+
         if index == 0 {
             // We want to emit errors in the self parameter and ignore TraitConstraintNotSatisfied with Placeholder
             // which may be recoverable on the second pass.
@@ -66,7 +69,8 @@ pub(crate) fn type_check_method_application(
             });
             handler.append(arg_handler);
         }
-        args_opt_buf.push_back((arg_opt, has_errors));
+
+        args_opt_buf.push_back((arg_opt, needs_second_pass));
     }
 
     // resolve the method name to a typed function declaration and type_check
@@ -109,26 +113,26 @@ pub(crate) fn type_check_method_application(
         if let (Some(arg), false) = arg_opt {
             args_buf.push_back(arg);
         } else {
+            // We type check the argument expression again this time throwing out the error.
             let param_index = if method.is_contract_call {
                 index - 1 //contract call methods don't have self parameter.
             } else {
                 index
             };
-            // This arg_opt is None because it failed in the first pass.
-            // We now try to type check it again, this time with the type annotation.
-            let ctx = ctx
-                .by_ref()
-                .with_help_text(
-                    "Function application argument type must match function parameter type.",
-                )
-                .with_type_annotation(
-                    method
-                        .parameters
-                        .get(param_index)
-                        .unwrap()
-                        .type_argument
-                        .type_id,
-                );
+
+            let ctx = if let Some(param) = method.parameters.get(param_index) {
+                // We now try to type check it again, this time with the type annotation.
+                ctx.by_ref()
+                    .with_help_text(
+                        "Function application argument type must match function parameter type.",
+                    )
+                    .with_type_annotation(param.type_argument.type_id)
+            } else {
+                ctx.by_ref()
+                    .with_help_text("")
+                    .with_type_annotation(type_engine.insert(engines, TypeInfo::Unknown, None))
+            };
+
             args_buf.push_back(
                 ty::TyExpression::type_check(handler, ctx, arg)
                     .unwrap_or_else(|err| ty::TyExpression::error(err, span.clone(), engines)),
@@ -144,20 +148,10 @@ pub(crate) fn type_check_method_application(
         }));
     }
 
-    // check the function storage purity
-    if !method.is_contract_call {
-        // 'method.purity' is that of the callee, 'opts.purity' of the caller.
-        if !ctx.purity().can_call(method.purity) {
-            handler.emit_err(CompileError::StorageAccessMismatch {
-                attrs: promote_purity(ctx.purity(), method.purity).to_attribute_syntax(),
-                span: method_name_binding.inner.easy_name().span(),
-            });
-        }
-        if !contract_call_params.is_empty() {
-            handler.emit_err(CompileError::CallParamForNonContractCallMethod {
-                span: contract_call_params[0].name.span(),
-            });
-        }
+    if !method.is_contract_call && !contract_call_params.is_empty() {
+        handler.emit_err(CompileError::CallParamForNonContractCallMethod {
+            span: contract_call_params[0].name.span(),
+        });
     }
 
     // generate the map of the contract call params
@@ -396,14 +390,19 @@ pub(crate) fn type_check_method_application(
                 )));
             }
         };
-        let func_selector = method
-            .to_fn_selector_value(handler, engines)
-            .unwrap_or([0; 4]);
-        let contract_caller = contract_caller.unwrap();
+        let func_selector = if ctx.experimental.new_encoding {
+            None
+        } else {
+            Some(
+                method
+                    .to_fn_selector_value(handler, engines)
+                    .unwrap_or([0; 4]),
+            )
+        };
         Some(ty::ContractCallParams {
             func_selector,
             contract_address: contract_address.clone(),
-            contract_caller: Box::new(contract_caller),
+            contract_caller: Box::new(contract_caller.unwrap()),
         })
     } else {
         None
@@ -484,6 +483,7 @@ pub(crate) fn type_check_method_application(
                             ]),
                             span: Span::dummy(),
                         },
+                        resolved_call_path_binding: None,
                         arguments: vec![
                             Expression {
                                 kind: ExpressionKind::Literal(Literal::B256([0u8; 32])),
@@ -581,7 +581,7 @@ pub(crate) fn type_check_method_application(
 
     // Unify method type parameters with implementing type type parameters.
     if let Some(implementing_for_typeid) = method.implementing_for_typeid {
-        if let Some(TyDecl::ImplTrait(t)) = method.clone().implementing_type {
+        if let Some(TyDecl::ImplSelfOrTrait(t)) = method.clone().implementing_type {
             let t = &engines.de().get(&t.decl_id).implementing_for;
             if let TypeInfo::Custom {
                 type_arguments: Some(type_arguments),
@@ -644,41 +644,82 @@ pub(crate) fn type_check_method_application(
     {
         fn_ref = cached_fn_ref;
     } else {
-        // This handles the case of substituting the generic blanket type by call_path_typeid.
-        if let Some(TyDecl::ImplTrait(t)) = method.clone().implementing_type {
+        if let Some(TyDecl::ImplSelfOrTrait(t)) = method.clone().implementing_type {
             let t = &engines.de().get(&t.decl_id).implementing_for;
             if let TypeInfo::Custom {
                 qualified_call_path,
-                type_arguments: _,
+                type_arguments,
                 root_type_id: _,
             } = &*type_engine.get(t.initial_type_id)
             {
+                let mut subst_type_parameters = vec![];
+                let mut subst_type_arguments = vec![];
+
+                let mut names_type_ids = HashMap::<Ident, TypeId>::new();
+                if let Some(type_arguments) = type_arguments {
+                    for t_arg in type_arguments.iter() {
+                        if let TypeInfo::Custom {
+                            qualified_call_path,
+                            ..
+                        } = &*type_engine.get(t_arg.initial_type_id)
+                        {
+                            names_type_ids.insert(
+                                qualified_call_path.call_path.suffix.clone(),
+                                t_arg.type_id,
+                            );
+                        }
+                    }
+                }
+
+                // This handles the case of substituting the generic blanket type by call_path_typeid.
                 for p in method.type_parameters.clone() {
                     if p.name_ident.as_str() == qualified_call_path.call_path.suffix.as_str() {
-                        let type_subst = TypeSubstMap::from_type_parameters_and_type_arguments(
-                            vec![t.initial_type_id],
-                            vec![call_path_typeid],
-                        );
-                        method.subst(&type_subst, engines);
+                        subst_type_parameters.push(t.initial_type_id);
+                        subst_type_arguments.push(call_path_typeid);
+                        break;
+                    }
+                }
+
+                // This will subst inner method_application placeholders with the already resolved
+                // current method application type parameter
+                for p in method.type_parameters.clone() {
+                    if names_type_ids.contains_key(&p.name_ident) {
+                        subst_type_parameters.push(engines.te().insert(
+                            engines,
+                            TypeInfo::Placeholder(p.clone()),
+                            p.span().source_id(),
+                        ));
+                        subst_type_arguments.push(p.type_id);
                     }
                 }
+
+                let type_subst = TypeSubstMap::from_type_parameters_and_type_arguments(
+                    subst_type_parameters,
+                    subst_type_arguments,
+                );
+
+                method.subst(&SubstTypesContext::new(
+                    engines,
+                    &type_subst,
+                    !ctx.code_block_first_pass(),
+                ));
             }
         }
 
-        // Handle the trait constraints. This includes checking to see if the trait
-        // constraints are satisfied and replacing old decl ids based on the
-        // constraint with new decl ids based on the new type.
-        let decl_mapping = TypeParameter::gather_decl_mapping_from_trait_constraints(
-            handler,
-            ctx.by_ref(),
-            &method.type_parameters,
-            method.name.as_str(),
-            &call_path.span(),
-        )
-        .ok();
-
-        if let Some(decl_mapping) = decl_mapping {
-            if !ctx.defer_monomorphization() {
+        if !ctx.code_block_first_pass() {
+            // Handle the trait constraints. This includes checking to see if the trait
+            // constraints are satisfied and replacing old decl ids based on the
+            // constraint with new decl ids based on the new type.
+            let decl_mapping = TypeParameter::gather_decl_mapping_from_trait_constraints(
+                handler,
+                ctx.by_ref(),
+                &method.type_parameters,
+                method.name.as_str(),
+                &call_path.span(),
+            )
+            .ok();
+
+            if let Some(decl_mapping) = decl_mapping {
                 method.replace_decls(&decl_mapping, handler, &mut ctx)?;
             }
         }
@@ -688,10 +729,10 @@ pub(crate) fn type_check_method_application(
         method_return_type_id = method.return_type.type_id;
         decl_engine.replace(*fn_ref.id(), method.clone());
 
-        if method_sig.is_concrete(engines)
+        if !ctx.code_block_first_pass()
+            && method_sig.is_concrete(engines)
             && method.is_type_check_finalized
             && !method.is_trait_method_dummy
-            && !ctx.defer_monomorphization()
         {
             ctx.engines()
                 .qe()
@@ -706,7 +747,6 @@ pub(crate) fn type_check_method_application(
         selector,
         type_binding: Some(method_name_binding.strip_inner()),
         call_path_typeid: Some(call_path_typeid),
-        deferred_monomorphization: ctx.defer_monomorphization(),
         contract_call_params: contract_call_params_map,
         contract_caller: None,
     };
@@ -813,9 +853,9 @@ pub(crate) fn resolve_method_name(
                 ctx.namespace().prepend_module_path(&call_path.prefixes)
             } else {
                 let mut module_path = call_path.prefixes.clone();
-                if let (Some(root_mod), Some(root_name)) = (
+                if let (Some(root_mod), root_name) = (
                     module_path.first().cloned(),
-                    ctx.namespace().root_module_name().clone(),
+                    ctx.namespace().root_module().name().clone(),
                 ) {
                     if root_mod.as_str() == root_name.as_str() {
                         module_path.remove(0);
@@ -924,7 +964,10 @@ pub(crate) fn monomorphize_method(
     }
 
     let decl_ref = decl_engine
-        .insert(func_decl)
+        .insert(
+            func_decl,
+            decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+        )
         .with_parent(decl_engine, (*decl_ref.id()).into());
 
     Ok(decl_ref)
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/struct_instantiation.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/struct_instantiation.rs
index 95f64d0add9..23ff00f7894 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/struct_instantiation.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/struct_instantiation.rs
@@ -1,3 +1,5 @@
+use std::collections::BTreeSet;
+
 use itertools::Itertools;
 use sway_error::{
     error::{CompileError, StructFieldUsageContext},
@@ -13,9 +15,7 @@ use crate::{
         CallPath, Visibility,
     },
     namespace::ResolvedTraitImplItem,
-    semantic_analysis::{
-        type_check_context::EnforceTypeArguments, GenericShadowingMode, TypeCheckContext,
-    },
+    semantic_analysis::{GenericShadowingMode, TypeCheckContext},
     type_system::*,
     Engines, Namespace,
 };
@@ -96,8 +96,8 @@ pub(crate) fn struct_instantiation(
 
     // extract the struct name and fields from the type info
     let type_info = type_engine.get(type_id);
-    let struct_ref = type_info.expect_struct(handler, engines, &span)?;
-    let struct_decl = decl_engine.get_struct(&struct_ref);
+    let struct_id = type_info.expect_struct(handler, engines, &span)?;
+    let struct_decl = decl_engine.get_struct(&struct_id);
 
     let (struct_can_be_changed, is_public_struct_access) =
         StructAccessInfo::get_info(engines, &struct_decl, ctx.namespace()).into();
@@ -140,6 +140,18 @@ pub(crate) fn struct_instantiation(
         });
     }
 
+    // Check that there are no duplicate fields.
+    let mut seen_fields: BTreeSet<Ident> = BTreeSet::new();
+    for field in fields.iter() {
+        if let Some(duplicate) = seen_fields.get(&field.name) {
+            handler.emit_err(CompileError::StructFieldDuplicated {
+                field_name: field.name.clone(),
+                duplicate: duplicate.clone(),
+            });
+        }
+        seen_fields.insert(field.name.clone());
+    }
+
     // Check that there are no extra fields.
     for field in fields.iter() {
         if !struct_fields.iter().any(|x| x.name == field.name) {
@@ -228,8 +240,8 @@ pub(crate) fn struct_instantiation(
     let context_expected_type_id = type_engine.get_unaliased_type_id(ctx.type_annotation());
     let (is_context_type_used, type_check_struct_decl, help_text) =
         match &*type_engine.get(context_expected_type_id) {
-            TypeInfo::Struct(s) => {
-                let context_expected_struct_decl = decl_engine.get_struct(s.id());
+            TypeInfo::Struct(decl_id) => {
+                let context_expected_struct_decl = decl_engine.get_struct(decl_id);
                 if UnifyCheck::coercion(engines)
                     .check_structs(&context_expected_struct_decl, &struct_decl)
                 {
@@ -291,7 +303,7 @@ pub(crate) fn struct_instantiation(
 
     let instantiation_span = inner_span.clone();
     ctx.with_generic_shadowing_mode(GenericShadowingMode::Allow)
-        .scoped(|mut scoped_ctx| {
+        .scoped(handler, None, |mut scoped_ctx| {
             // Insert struct type parameter into namespace.
             // This is required so check_type_parameter_bounds can resolve generic trait type parameters.
             for type_parameter in struct_decl.type_parameters.iter() {
@@ -302,7 +314,7 @@ pub(crate) fn struct_instantiation(
 
             let exp = ty::TyExpression {
                 expression: ty::TyExpressionVariant::StructExpression {
-                    struct_ref,
+                    struct_id,
                     fields: typed_fields,
                     instantiation_span,
                     call_path_binding,
diff --git a/sway-core/src/semantic_analysis/ast_node/mod.rs b/sway-core/src/semantic_analysis/ast_node/mod.rs
index 4ce77481489..3a6ea5f2153 100644
--- a/sway-core/src/semantic_analysis/ast_node/mod.rs
+++ b/sway-core/src/semantic_analysis/ast_node/mod.rs
@@ -7,12 +7,7 @@ pub(crate) use expression::*;
 pub(crate) use modes::*;
 
 use crate::{
-    engine_threading::SpannedWithEngines,
-    language::{
-        parsed::*,
-        ty::{self, TyDecl},
-    },
-    namespace::TraitMap,
+    language::{parsed::*, ty},
     semantic_analysis::*,
     type_system::*,
     Engines, Ident,
@@ -24,7 +19,7 @@ use sway_error::{
 };
 use sway_types::{span::Span, Spanned};
 
-use super::collection_context::SymbolCollectionContext;
+use super::symbol_collection_context::SymbolCollectionContext;
 
 impl ty::TyAstNode {
     pub(crate) fn collect(
@@ -39,7 +34,9 @@ impl ty::TyAstNode {
             }
             AstNodeContent::IncludeStatement(_i) => (),
             AstNodeContent::Declaration(decl) => ty::TyDecl::collect(handler, engines, ctx, decl)?,
-            AstNodeContent::Expression(_expr) => (),
+            AstNodeContent::Expression(expr) => {
+                ty::TyExpression::collect(handler, engines, ctx, &expr)?
+            }
             AstNodeContent::Error(_spans, _err) => (),
         };
 
@@ -59,7 +56,6 @@ impl ty::TyAstNode {
             content: match node.content.clone() {
                 AstNodeContent::UseStatement(stmt) => {
                     handle_use_statement(&mut ctx, engines, &stmt, handler);
-                    handle_item_trait_imports(&mut ctx, engines, handler)?;
                     ty::TyAstNodeContent::SideEffect(ty::TySideEffect {
                         side_effect: ty::TySideEffectVariant::UseStatement(ty::TyUseStatement {
                             alias: stmt.alias,
@@ -138,56 +134,6 @@ impl ty::TyAstNode {
     }
 }
 
-fn handle_item_trait_imports(
-    ctx: &mut TypeCheckContext<'_>,
-    engines: &Engines,
-    handler: &Handler,
-) -> Result<(), ErrorEmitted> {
-    let mut impls_to_insert = TraitMap::default();
-
-    let root_mod = &ctx.namespace().root().module;
-    let dst_mod = ctx.namespace.module(engines);
-
-    for (_, (_, src, decl)) in dst_mod.current_items().use_item_synonyms.iter() {
-        let decl = decl.expect_typed_ref();
-
-        let src_mod = root_mod.lookup_submodule(handler, engines, src)?;
-
-        //  if this is an enum or struct or function, import its implementations
-        if let Ok(type_id) = decl.return_type(&Handler::default(), engines) {
-            impls_to_insert.extend(
-                src_mod
-                    .current_items()
-                    .implemented_traits
-                    .filter_by_type_item_import(type_id, engines),
-                engines,
-            );
-        }
-        // if this is a trait, import its implementations
-        let decl_span = decl.span(engines);
-        if matches!(decl, TyDecl::TraitDecl(_)) {
-            // TODO: we only import local impls from the source namespace
-            // this is okay for now but we'll need to device some mechanism to collect all
-            // available trait impls
-            impls_to_insert.extend(
-                src_mod
-                    .current_items()
-                    .implemented_traits
-                    .filter_by_trait_decl_span(decl_span),
-                engines,
-            );
-        }
-    }
-
-    let dst_mod = ctx.namespace_mut().module_mut(engines);
-    dst_mod
-        .current_items_mut()
-        .implemented_traits
-        .extend(impls_to_insert, engines);
-
-    Ok(())
-}
-
 fn collect_use_statement(
     handler: &Handler,
     engines: &Engines,
@@ -223,7 +169,7 @@ fn collect_use_statement(
         ImportType::Star => {
             // try a standard starimport first
             let star_import_handler = Handler::default();
-            let import = ctx.star_import(&star_import_handler, engines, &path);
+            let import = ctx.star_import(&star_import_handler, engines, &path, stmt.reexport);
             if import.is_ok() {
                 handler.append(star_import_handler);
                 import
@@ -231,8 +177,13 @@ fn collect_use_statement(
                 // if it doesn't work it could be an enum star import
                 if let Some((enum_name, path)) = path.split_last() {
                     let variant_import_handler = Handler::default();
-                    let variant_import =
-                        ctx.variant_star_import(&variant_import_handler, engines, path, enum_name);
+                    let variant_import = ctx.variant_star_import(
+                        &variant_import_handler,
+                        engines,
+                        path,
+                        enum_name,
+                        stmt.reexport,
+                    );
                     if variant_import.is_ok() {
                         handler.append(variant_import_handler);
                         variant_import
@@ -246,12 +197,20 @@ fn collect_use_statement(
                 }
             }
         }
-        ImportType::SelfImport(_) => ctx.self_import(handler, engines, &path, stmt.alias.clone()),
+        ImportType::SelfImport(_) => {
+            ctx.self_import(handler, engines, &path, stmt.alias.clone(), stmt.reexport)
+        }
         ImportType::Item(ref s) => {
             // try a standard item import first
             let item_import_handler = Handler::default();
-            let import =
-                ctx.item_import(&item_import_handler, engines, &path, s, stmt.alias.clone());
+            let import = ctx.item_import(
+                &item_import_handler,
+                engines,
+                &path,
+                s,
+                stmt.alias.clone(),
+                stmt.reexport,
+            );
 
             if import.is_ok() {
                 handler.append(item_import_handler);
@@ -267,6 +226,7 @@ fn collect_use_statement(
                         enum_name,
                         s,
                         stmt.alias.clone(),
+                        stmt.reexport,
                     );
                     if variant_import.is_ok() {
                         handler.append(variant_import_handler);
@@ -308,7 +268,7 @@ fn handle_use_statement(
         ImportType::Star => {
             // try a standard starimport first
             let star_import_handler = Handler::default();
-            let import = ctx.star_import(&star_import_handler, &path);
+            let import = ctx.star_import(&star_import_handler, &path, stmt.reexport);
             if import.is_ok() {
                 handler.append(star_import_handler);
                 import
@@ -316,8 +276,12 @@ fn handle_use_statement(
                 // if it doesn't work it could be an enum star import
                 if let Some((enum_name, path)) = path.split_last() {
                     let variant_import_handler = Handler::default();
-                    let variant_import =
-                        ctx.variant_star_import(&variant_import_handler, path, enum_name);
+                    let variant_import = ctx.variant_star_import(
+                        &variant_import_handler,
+                        path,
+                        enum_name,
+                        stmt.reexport,
+                    );
                     if variant_import.is_ok() {
                         handler.append(variant_import_handler);
                         variant_import
@@ -331,11 +295,19 @@ fn handle_use_statement(
                 }
             }
         }
-        ImportType::SelfImport(_) => ctx.self_import(handler, &path, stmt.alias.clone()),
+        ImportType::SelfImport(_) => {
+            ctx.self_import(handler, &path, stmt.alias.clone(), stmt.reexport)
+        }
         ImportType::Item(ref s) => {
             // try a standard item import first
             let item_import_handler = Handler::default();
-            let import = ctx.item_import(&item_import_handler, &path, s, stmt.alias.clone());
+            let import = ctx.item_import(
+                &item_import_handler,
+                &path,
+                s,
+                stmt.alias.clone(),
+                stmt.reexport,
+            );
 
             if import.is_ok() {
                 handler.append(item_import_handler);
@@ -350,6 +322,7 @@ fn handle_use_statement(
                         enum_name,
                         s,
                         stmt.alias.clone(),
+                        stmt.reexport,
                     );
                     if variant_import.is_ok() {
                         handler.append(variant_import_handler);
diff --git a/sway-core/src/semantic_analysis/cei_pattern_analysis.rs b/sway-core/src/semantic_analysis/cei_pattern_analysis.rs
index 91a2b7f9c4a..1dbad596ed4 100644
--- a/sway-core/src/semantic_analysis/cei_pattern_analysis.rs
+++ b/sway-core/src/semantic_analysis/cei_pattern_analysis.rs
@@ -11,7 +11,7 @@
 use crate::{
     decl_engine::*,
     language::{
-        ty::{self, TyFunctionDecl, TyImplTrait},
+        ty::{self, TyFunctionDecl, TyImplSelfOrTrait},
         AsmOp,
     },
     Engines,
@@ -30,6 +30,8 @@ enum Effect {
     BalanceTreeRead,      // balance tree read operation
     BalanceTreeReadWrite, // balance tree read and write operation
     OutputMessage,        // operation creates a new `Output::Message`
+    MintAsset,            // mint operation
+    BurnAsset,            // burn operation
 }
 
 impl fmt::Display for Effect {
@@ -42,6 +44,8 @@ impl fmt::Display for Effect {
             BalanceTreeRead => write!(f, "Balance tree read"),
             BalanceTreeReadWrite => write!(f, "Balance tree update"),
             OutputMessage => write!(f, "Output message sent"),
+            MintAsset => write!(f, "Asset minted"),
+            BurnAsset => write!(f, "Asset burned"),
         }
     }
 }
@@ -56,6 +60,8 @@ impl Effect {
             BalanceTreeRead => "making all balance tree reads",
             BalanceTreeReadWrite => "making all balance tree updates",
             OutputMessage => "sending all output messages",
+            MintAsset => "minting assets",
+            BurnAsset => "burning assets",
         })
     }
 }
@@ -105,7 +111,7 @@ fn contract_entry_points(
             Declaration(ty::TyDecl::FunctionDecl(ty::FunctionDecl { decl_id, .. })) => {
                 decl_id_to_fn_decls(decl_engine, decl_id)
             }
-            Declaration(ty::TyDecl::ImplTrait(ty::ImplTrait { decl_id, .. })) => {
+            Declaration(ty::TyDecl::ImplSelfOrTrait(ty::ImplSelfOrTrait { decl_id, .. })) => {
                 impl_trait_methods(decl_engine, decl_id)
             }
             _ => vec![],
@@ -122,9 +128,9 @@ fn decl_id_to_fn_decls(
 
 fn impl_trait_methods(
     decl_engine: &DeclEngine,
-    impl_trait_decl_id: &DeclId<TyImplTrait>,
+    impl_trait_decl_id: &DeclId<TyImplSelfOrTrait>,
 ) -> Vec<Arc<ty::TyFunctionDecl>> {
-    let impl_trait = decl_engine.get_impl_trait(impl_trait_decl_id);
+    let impl_trait = decl_engine.get_impl_self_or_trait(impl_trait_decl_id);
     impl_trait
         .items
         .iter()
@@ -641,7 +647,9 @@ fn effects_of_intrinsic(intr: &sway_ast::Intrinsic) -> HashSet<Effect> {
         | Not
         | EncodeBufferEmpty
         | EncodeBufferAppend
-        | EncodeBufferAsRawSlice => HashSet::new(),
+        | EncodeBufferAsRawSlice
+        | Slice
+        | ElemAt => HashSet::new(),
     }
 }
 
@@ -653,6 +661,8 @@ fn effects_of_asm_op(op: &AsmOp) -> HashSet<Effect> {
         "bal" => HashSet::from([Effect::BalanceTreeRead]),
         "smo" => HashSet::from([Effect::OutputMessage]),
         "call" => HashSet::from([Effect::Interaction]),
+        "mint" => HashSet::from([Effect::MintAsset]),
+        "burn" => HashSet::from([Effect::BurnAsset]),
         // the rest of the assembly instructions are considered to not have effects
         _ => HashSet::new(),
     }
diff --git a/sway-core/src/semantic_analysis/module.rs b/sway-core/src/semantic_analysis/module.rs
index f377c9acd95..8acdf1cac09 100644
--- a/sway-core/src/semantic_analysis/module.rs
+++ b/sway-core/src/semantic_analysis/module.rs
@@ -2,6 +2,7 @@ use std::{
     collections::{HashMap, HashSet},
     fmt::Display,
     fs,
+    sync::Arc,
 };
 
 use graph_cycles::Cycles;
@@ -9,23 +10,25 @@ use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
 };
-use sway_types::{BaseIdent, Named};
+use sway_types::{BaseIdent, Named, SourceId};
 
 use crate::{
     decl_engine::{DeclEngineGet, DeclId},
-    engine_threading::DebugWithEngines,
+    engine_threading::{DebugWithEngines, PartialEqWithEngines, PartialEqWithEnginesContext},
+    is_ty_module_cache_up_to_date,
     language::{
         parsed::*,
         ty::{self, TyAstNodeContent, TyDecl},
         CallPath, ModName,
     },
+    query_engine::{ModuleCacheKey, TypedModuleInfo},
     semantic_analysis::*,
-    Engines, TypeInfo,
+    BuildConfig, Engines, TypeInfo,
 };
 
 use super::{
-    collection_context::SymbolCollectionContext,
     declaration::auto_impl::{self, EncodingAutoImplContext},
+    symbol_collection_context::SymbolCollectionContext,
 };
 
 #[derive(Clone, Debug)]
@@ -254,6 +257,42 @@ impl ty::TyModule {
         Ok(())
     }
 
+    /// Retrieves a cached typed module if it's up to date.
+    ///
+    /// This function checks the cache for a typed module corresponding to the given source ID.
+    /// If found and up to date, it returns the cached module. Otherwise, it returns None.
+    fn get_cached_ty_module_if_up_to_date(
+        source_id: Option<&SourceId>,
+        engines: &Engines,
+        build_config: Option<&BuildConfig>,
+    ) -> Option<Arc<ty::TyModule>> {
+        let source_id = source_id?;
+
+        // Create a cache key and get the module cache
+        let path = engines.se().get_path(source_id);
+        let include_tests = build_config.map_or(false, |x| x.include_tests);
+        let key = ModuleCacheKey::new(path.clone().into(), include_tests);
+        let cache = engines.qe().module_cache.read();
+        cache.get(&key).and_then(|entry| {
+            entry.typed.as_ref().and_then(|typed| {
+                // Check if the cached module is up to date
+                let is_up_to_date = is_ty_module_cache_up_to_date(
+                    engines,
+                    &path.into(),
+                    include_tests,
+                    build_config,
+                );
+
+                // Return the cached module if it's up to date, otherwise None
+                if is_up_to_date {
+                    Some(typed.module.clone())
+                } else {
+                    None
+                }
+            })
+        })
+    }
+
     /// Type-check the given parsed module to produce a typed module.
     ///
     /// Recursively type-checks submodules first.
@@ -263,7 +302,8 @@ impl ty::TyModule {
         engines: &Engines,
         kind: TreeType,
         parsed: &ParseModule,
-    ) -> Result<Self, ErrorEmitted> {
+        build_config: Option<&BuildConfig>,
+    ) -> Result<Arc<Self>, ErrorEmitted> {
         let ParseModule {
             submodules,
             tree,
@@ -273,25 +313,51 @@ impl ty::TyModule {
             ..
         } = parsed;
 
+        // Try to get the cached root module if it's up to date
+        if let Some(module) = ty::TyModule::get_cached_ty_module_if_up_to_date(
+            parsed.span.source_id(),
+            engines,
+            build_config,
+        ) {
+            return Ok(module);
+        }
+
         // Type-check submodules first in order of evaluation previously computed by the dependency graph.
         let submodules_res = module_eval_order
             .iter()
             .map(|eval_mod_name| {
                 let (name, submodule) = submodules
                     .iter()
-                    .find(|(submod_name, _submodule)| eval_mod_name == submod_name)
+                    .find(|(submod_name, _)| eval_mod_name == submod_name)
                     .unwrap();
-                Ok((
-                    name.clone(),
-                    ty::TySubmodule::type_check(
+
+                // Try to get the cached submodule
+                if let Some(cached_module) = ty::TyModule::get_cached_ty_module_if_up_to_date(
+                    submodule.module.span.source_id(),
+                    engines,
+                    build_config,
+                ) {
+                    // If cached, create TySubmodule from cached module
+                    Ok::<(BaseIdent, ty::TySubmodule), ErrorEmitted>((
+                        name.clone(),
+                        ty::TySubmodule {
+                            module: cached_module,
+                            mod_name_span: submodule.mod_name_span.clone(),
+                        },
+                    ))
+                } else {
+                    // If not cached, type-check the submodule
+                    let type_checked_submodule = ty::TySubmodule::type_check(
                         handler,
                         ctx.by_ref(),
                         engines,
                         name.clone(),
                         kind,
                         submodule,
-                    )?,
-                ))
+                        build_config,
+                    )?;
+                    Ok((name.clone(), type_checked_submodule))
+                }
             })
             .collect::<Result<Vec<_>, _>>();
 
@@ -303,7 +369,6 @@ impl ty::TyModule {
         )?;
 
         let mut all_nodes = Self::type_check_nodes(handler, ctx.by_ref(), &ordered_nodes)?;
-
         let submodules = submodules_res?;
 
         let fallback_fn = collect_fallback_fn(&all_nodes, engines, handler)?;
@@ -350,14 +415,34 @@ impl ty::TyModule {
                     }
                 }
                 (TreeType::Contract, _) => {
+                    // collect all supertrait methods
+                    let contract_supertrait_fns = submodules
+                        .iter()
+                        .flat_map(|x| x.1.module.submodules_recursive())
+                        .flat_map(|x| x.1.module.contract_supertrait_fns(engines))
+                        .chain(
+                            all_nodes
+                                .iter()
+                                .flat_map(|x| x.contract_supertrait_fns(engines)),
+                        )
+                        .collect::<Vec<_>>();
+
                     // collect all contract methods
-                    let contract_fns = submodules
+                    let mut contract_fns = submodules
                         .iter()
                         .flat_map(|x| x.1.module.submodules_recursive())
                         .flat_map(|x| x.1.module.contract_fns(engines))
                         .chain(all_nodes.iter().flat_map(|x| x.contract_fns(engines)))
                         .collect::<Vec<_>>();
 
+                    // exclude all contract methods that are supertrait methods
+                    let partialeq_ctx = PartialEqWithEnginesContext::new(engines);
+                    contract_fns.retain(|method| {
+                        contract_supertrait_fns
+                            .iter()
+                            .all(|si| !PartialEqWithEngines::eq(method, si, &partialeq_ctx))
+                    });
+
                     let mut fn_generator =
                         auto_impl::EncodingAutoImplContext::new(&mut ctx).unwrap();
                     if let Ok(node) = fn_generator.generate_contract_entry(
@@ -374,20 +459,42 @@ impl ty::TyModule {
             }
         }
 
-        Ok(Self {
+        #[allow(clippy::arc_with_non_send_sync)]
+        let ty_module = Arc::new(Self {
             span: span.clone(),
             submodules,
             namespace: ctx.namespace.clone(),
             all_nodes,
             attributes: attributes.clone(),
-        })
+        });
+
+        // Cache the ty module
+        if let Some(source_id) = span.source_id() {
+            let path = engines.se().get_path(source_id);
+            let version = build_config
+                .and_then(|config| config.lsp_mode.as_ref())
+                .and_then(|lsp| lsp.file_versions.get(&path).copied())
+                .flatten();
+
+            let include_tests = build_config.map_or(false, |x| x.include_tests);
+            let key = ModuleCacheKey::new(path.clone().into(), include_tests);
+            engines.qe().update_typed_module_cache_entry(
+                &key,
+                TypedModuleInfo {
+                    module: ty_module.clone(),
+                    version,
+                },
+            );
+        }
+
+        Ok(ty_module)
     }
 
     // Filter and gather impl items
     fn get_all_impls(
         ctx: TypeCheckContext<'_>,
         nodes: &[AstNode],
-        predicate: fn(&ImplTrait) -> bool,
+        predicate: fn(&ImplSelfOrTrait) -> bool,
     ) -> HashMap<BaseIdent, HashSet<CallPath>> {
         let engines = ctx.engines();
         // Check which structs and enums needs to have auto impl for AbiEncode
@@ -396,14 +503,16 @@ impl ty::TyModule {
         let mut impls = HashMap::<BaseIdent, HashSet<CallPath>>::new();
 
         for node in nodes.iter() {
-            if let AstNodeContent::Declaration(Declaration::ImplTrait(decl_id)) = &node.content {
-                let decl = &*engines.pe().get_impl_trait(decl_id);
+            if let AstNodeContent::Declaration(Declaration::ImplSelfOrTrait(decl_id)) =
+                &node.content
+            {
+                let decl = &*engines.pe().get_impl_self_or_trait(decl_id);
                 let implementing_for = ctx.engines.te().get(decl.implementing_for.type_id);
                 let implementing_for = match &*implementing_for {
-                    TypeInfo::Struct(decl) => {
-                        Some(ctx.engines().de().get(decl.id()).name().clone())
+                    TypeInfo::Struct(decl_id) => {
+                        Some(ctx.engines().de().get(decl_id).name().clone())
                     }
-                    TypeInfo::Enum(decl) => Some(ctx.engines().de().get(decl.id()).name().clone()),
+                    TypeInfo::Enum(decl) => Some(ctx.engines().de().get(decl).name().clone()),
                     TypeInfo::Custom {
                         qualified_call_path,
                         ..
@@ -440,11 +549,11 @@ impl ty::TyModule {
             let auto_impl_encoding_traits = match &node.content {
                 AstNodeContent::Declaration(Declaration::StructDeclaration(decl_id)) => {
                     let decl = ctx.engines().pe().get_struct(decl_id);
-                    all_abiencode_impls.get(&decl.name).is_none()
+                    !all_abiencode_impls.contains_key(&decl.name)
                 }
                 AstNodeContent::Declaration(Declaration::EnumDeclaration(decl_id)) => {
                     let decl = ctx.engines().pe().get_enum(decl_id);
-                    all_abiencode_impls.get(&decl.name).is_none()
+                    !all_abiencode_impls.contains_key(&decl.name)
                 }
                 _ => false,
             };
@@ -593,6 +702,7 @@ impl ty::TySubmodule {
         mod_name: ModName,
         kind: TreeType,
         submodule: &ParseSubmodule,
+        build_config: Option<&BuildConfig>,
     ) -> Result<Self, ErrorEmitted> {
         let ParseSubmodule {
             module,
@@ -600,7 +710,8 @@ impl ty::TySubmodule {
             visibility,
         } = submodule;
         parent_ctx.enter_submodule(mod_name, *visibility, module.span.clone(), |submod_ctx| {
-            let module_res = ty::TyModule::type_check(handler, submod_ctx, engines, kind, module);
+            let module_res =
+                ty::TyModule::type_check(handler, submod_ctx, engines, kind, module, build_config);
             module_res.map(|module| ty::TySubmodule {
                 module,
                 mod_name_span: mod_name_span.clone(),
diff --git a/sway-core/src/semantic_analysis/namespace/contract_helpers.rs b/sway-core/src/semantic_analysis/namespace/contract_helpers.rs
index 0b1a5851e0c..822d4262156 100644
--- a/sway-core/src/semantic_analysis/namespace/contract_helpers.rs
+++ b/sway-core/src/semantic_analysis/namespace/contract_helpers.rs
@@ -12,7 +12,7 @@ use crate::{
         ty::{TyAstNode, TyAstNodeContent},
         Visibility,
     },
-    semantic_analysis::TypeCheckContext,
+    semantic_analysis::{symbol_collection_context::SymbolCollectionContext, TypeCheckContext},
     transform::to_parsed_lang,
     Engines, Namespace,
 };
@@ -26,25 +26,34 @@ use super::{lexical_scope::SymbolMap, root::ResolvedDeclaration, Module, Root};
 /// `CONTRACT_ID`-containing modules: https://github.com/FuelLabs/sway/issues/3077
 pub fn default_with_contract_id(
     engines: &Engines,
-    name: Option<Ident>,
+    name: Ident,
+    visibility: Visibility,
     contract_id_value: String,
     experimental: crate::ExperimentalFlags,
 ) -> Result<Module, vec1::Vec1<CompileError>> {
     let handler = <_>::default();
-    default_with_contract_id_inner(&handler, engines, name, contract_id_value, experimental)
-        .map_err(|_| {
-            let (errors, warnings) = handler.consume();
-            assert!(warnings.is_empty());
+    default_with_contract_id_inner(
+        &handler,
+        engines,
+        name,
+        visibility,
+        contract_id_value,
+        experimental,
+    )
+    .map_err(|_| {
+        let (errors, warnings) = handler.consume();
+        assert!(warnings.is_empty());
 
-            // Invariant: `.value == None` => `!errors.is_empty()`.
-            vec1::Vec1::try_from_vec(errors).unwrap()
-        })
+        // Invariant: `.value == None` => `!errors.is_empty()`.
+        vec1::Vec1::try_from_vec(errors).unwrap()
+    })
 }
 
 fn default_with_contract_id_inner(
     handler: &Handler,
     engines: &Engines,
-    ns_name: Option<Ident>,
+    ns_name: Ident,
+    visibility: Visibility,
     contract_id_value: String,
     experimental: crate::ExperimentalFlags,
 ) -> Result<Module, ErrorEmitted> {
@@ -95,12 +104,14 @@ fn default_with_contract_id_inner(
         content: AstNodeContent::Declaration(Declaration::ConstantDeclaration(const_decl_id)),
         span: const_item_span.clone(),
     };
-    let root = Root::from(Module::default());
-    let mut ns = Namespace::init_root(root);
+    let mut root = Root::from(Module::new(ns_name.clone(), Visibility::Public, None));
+    let mut ns = Namespace::init_root(&mut root);
+
+    let symbol_ctx_ns = Namespace::default();
+    let mut symbol_ctx = SymbolCollectionContext::new(symbol_ctx_ns);
     // This is pretty hacky but that's okay because of this code is being removed pretty soon
-    ns.root.module.name = ns_name;
-    ns.root.module.visibility = Visibility::Public;
-    let type_check_ctx = TypeCheckContext::from_namespace(&mut ns, engines, experimental);
+    let type_check_ctx =
+        TypeCheckContext::from_namespace(&mut ns, &mut symbol_ctx, engines, experimental);
     let typed_node = TyAstNode::type_check(handler, type_check_ctx, &ast_node).unwrap();
     // get the decl out of the typed node:
     // we know as an invariant this must be a const decl, as we hardcoded a const decl in
@@ -118,7 +129,7 @@ fn default_with_contract_id_inner(
     };
     compiled_constants.insert(name, ResolvedDeclaration::Typed(typed_decl));
 
-    let mut ret = Module::default();
+    let mut ret = Module::new(ns_name, visibility, None);
     ret.current_lexical_scope_mut().items.symbols = compiled_constants;
     Ok(ret)
 }
diff --git a/sway-core/src/semantic_analysis/namespace/lexical_scope.rs b/sway-core/src/semantic_analysis/namespace/lexical_scope.rs
index 6789146b722..62203b13dda 100644
--- a/sway-core/src/semantic_analysis/namespace/lexical_scope.rs
+++ b/sway-core/src/semantic_analysis/namespace/lexical_scope.rs
@@ -4,7 +4,7 @@ use crate::{
     language::{
         parsed::{Declaration, FunctionDeclaration},
         ty::{self, StructAccessInfo, TyDecl, TyStorageDecl},
-        CallPath,
+        CallPath, Visibility,
     },
     namespace::*,
     semantic_analysis::{ast_node::ConstShadowingMode, GenericShadowingMode},
@@ -13,11 +13,12 @@ use crate::{
 
 use super::{root::ResolvedDeclaration, TraitMap};
 
+use parking_lot::RwLock;
 use sway_error::{
-    error::{CompileError, StructFieldUsageContext},
+    error::{CompileError, ShadowingSource, StructFieldUsageContext},
     handler::{ErrorEmitted, Handler},
 };
-use sway_types::{span::Span, Spanned};
+use sway_types::{span::Span, IdentUnique, Named, Spanned};
 
 use std::sync::Arc;
 
@@ -36,10 +37,21 @@ impl ResolvedFunctionDecl {
 }
 
 pub(super) type SymbolMap = im::OrdMap<Ident, ResolvedDeclaration>;
+pub(super) type SymbolUniqueMap = im::OrdMap<IdentUnique, ResolvedDeclaration>;
+
 type SourceIdent = Ident;
-pub(super) type GlobSynonyms = im::HashMap<Ident, Vec<(ModulePathBuf, ResolvedDeclaration)>>;
-pub(super) type ItemSynonyms =
-    im::HashMap<Ident, (Option<SourceIdent>, ModulePathBuf, ResolvedDeclaration)>;
+
+pub(super) type GlobSynonyms =
+    im::HashMap<Ident, Vec<(ModulePathBuf, ResolvedDeclaration, Visibility)>>;
+pub(super) type ItemSynonyms = im::HashMap<
+    Ident,
+    (
+        Option<SourceIdent>,
+        ModulePathBuf,
+        ResolvedDeclaration,
+        Visibility,
+    ),
+>;
 
 /// Represents a lexical scope integer-based identifier, which can be used to reference
 /// specific a lexical scope.
@@ -66,6 +78,13 @@ pub struct LexicalScope {
 pub struct Items {
     /// An ordered map from `Ident`s to their associated declarations.
     pub(crate) symbols: SymbolMap,
+
+    /// An ordered map from `IdentUnique`s to their associated declarations.
+    /// This uses an Arc<RwLock<SymbolUniqueMap>> so it is shared between all
+    /// Items clones. This is intended so we can keep the symbols of previous
+    /// lexical scopes while collecting_unifications scopes.
+    pub(crate) symbols_unique_while_collecting_unifications: Arc<RwLock<SymbolUniqueMap>>,
+
     pub(crate) implemented_traits: TraitMap,
     /// Contains symbols imported using star imports (`use foo::*`.).
     ///
@@ -137,6 +156,50 @@ impl Items {
         self.symbols().keys()
     }
 
+    pub fn resolve_symbol(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+        symbol: &Ident,
+    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
+        // Check locally declared items. Any name clash with imports will have already been reported as an error.
+        if let Some(decl) = self.symbols.get(symbol) {
+            return Ok(decl.clone());
+        }
+
+        // Check item imports
+        if let Some((_, _, decl, _)) = self.use_item_synonyms.get(symbol) {
+            return Ok(decl.clone());
+        }
+
+        // Check glob imports
+        if let Some(decls) = self.use_glob_synonyms.get(symbol) {
+            if decls.len() == 1 {
+                return Ok(decls[0].1.clone());
+            } else if decls.is_empty() {
+                return Err(handler.emit_err(CompileError::Internal(
+                    "The name {symbol} was bound in a star import, but no corresponding module paths were found",
+                    symbol.span(),
+                )));
+            } else {
+                return Err(handler.emit_err(CompileError::SymbolWithMultipleBindings {
+                    name: symbol.clone(),
+                    paths: decls
+                        .iter()
+                        .map(|(path, decl, _)| get_path_for_decl(path, decl, engines))
+                        .collect(),
+                    span: symbol.span(),
+                }));
+            }
+        }
+
+        // Symbol not found
+        Err(handler.emit_err(CompileError::SymbolNotFound {
+            name: symbol.clone(),
+            span: symbol.span(),
+        }))
+    }
+
     pub(crate) fn insert_parsed_symbol(
         &mut self,
         handler: &Handler,
@@ -153,9 +216,11 @@ impl Items {
             ResolvedDeclaration::Parsed(item),
             const_shadowing_mode,
             generic_shadowing_mode,
+            false,
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn insert_typed_symbol(
         &mut self,
         handler: &Handler,
@@ -164,6 +229,7 @@ impl Items {
         item: ty::TyDecl,
         const_shadowing_mode: ConstShadowingMode,
         generic_shadowing_mode: GenericShadowingMode,
+        collecting_unifications: bool,
     ) -> Result<(), ErrorEmitted> {
         self.insert_symbol(
             handler,
@@ -172,9 +238,11 @@ impl Items {
             ResolvedDeclaration::Typed(item),
             const_shadowing_mode,
             generic_shadowing_mode,
+            collecting_unifications,
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn insert_symbol(
         &mut self,
         handler: &Handler,
@@ -183,6 +251,7 @@ impl Items {
         item: ResolvedDeclaration,
         const_shadowing_mode: ConstShadowingMode,
         generic_shadowing_mode: GenericShadowingMode,
+        collecting_unifications: bool,
     ) -> Result<(), ErrorEmitted> {
         let parsed_decl_engine = engines.pe();
         let decl_engine = engines.de();
@@ -205,6 +274,13 @@ impl Items {
                     const_shadowing_mode,
                     generic_shadowing_mode,
                 ) {
+                    // A general remark for using the `ShadowingSource::LetVar`.
+                    // If the shadowing is detected at this stage, the variable is for
+                    // sure a local variable, because in the case of pattern matching
+                    // struct field variables, the error is already reported and
+                    // the compilation do not proceed to the point of inserting
+                    // the pattern variable into the items.
+
                     // variable shadowing a constant
                     (
                         constant_ident,
@@ -216,10 +292,10 @@ impl Items {
                         _,
                     ) => {
                         handler.emit_err(CompileError::ConstantsCannotBeShadowed {
-                            variable_or_constant: "Variable".to_string(),
+                            shadowing_source: ShadowingSource::LetVar,
                             name: (&name).into(),
                             constant_span: constant_ident.span(),
-                            constant_decl: if is_imported_constant {
+                            constant_decl_span: if is_imported_constant {
                                 parsed_decl_engine.get(decl_id).span.clone()
                             } else {
                                 Span::dummy()
@@ -227,6 +303,22 @@ impl Items {
                             is_alias,
                         });
                     }
+                    // variable shadowing a configurable
+                    (
+                        configurable_ident,
+                        ConfigurableDeclaration(_),
+                        _,
+                        _,
+                        VariableDeclaration { .. },
+                        _,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConfigurablesCannotBeShadowed {
+                            shadowing_source: ShadowingSource::LetVar,
+                            name: (&name).into(),
+                            configurable_span: configurable_ident.span(),
+                        });
+                    }
                     // constant shadowing a constant sequentially
                     (
                         constant_ident,
@@ -238,10 +330,10 @@ impl Items {
                         _,
                     ) => {
                         handler.emit_err(CompileError::ConstantsCannotBeShadowed {
-                            variable_or_constant: "Constant".to_string(),
+                            shadowing_source: ShadowingSource::Const,
                             name: (&name).into(),
                             constant_span: constant_ident.span(),
-                            constant_decl: if is_imported_constant {
+                            constant_decl_span: if is_imported_constant {
                                 parsed_decl_engine.get(decl_id).span.clone()
                             } else {
                                 Span::dummy()
@@ -249,6 +341,22 @@ impl Items {
                             is_alias,
                         });
                     }
+                    // constant shadowing a configurable sequentially
+                    (
+                        configurable_ident,
+                        ConfigurableDeclaration(_),
+                        _,
+                        _,
+                        ConstantDeclaration { .. },
+                        ConstShadowingMode::Sequential,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConfigurablesCannotBeShadowed {
+                            shadowing_source: ShadowingSource::Const,
+                            name: (&name).into(),
+                            configurable_span: configurable_ident.span(),
+                        });
+                    }
                     // constant shadowing a variable
                     (_, VariableDeclaration(decl_id), _, _, ConstantDeclaration { .. }, _, _) => {
                         handler.emit_err(CompileError::ConstantShadowsVariable {
@@ -258,17 +366,53 @@ impl Items {
                     }
                     // constant shadowing a constant item-style (outside of a function body)
                     (
+                        constant_ident,
+                        ConstantDeclaration { .. },
+                        _,
                         _,
                         ConstantDeclaration { .. },
+                        ConstShadowingMode::ItemStyle,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConstantDuplicatesConstantOrConfigurable {
+                            existing_constant_or_configurable: "Constant",
+                            new_constant_or_configurable: "Constant",
+                            name: (&name).into(),
+                            existing_span: constant_ident.span(),
+                        });
+                    }
+                    // constant shadowing a configurable item-style (outside of a function body)
+                    (
+                        configurable_ident,
+                        ConfigurableDeclaration { .. },
                         _,
                         _,
                         ConstantDeclaration { .. },
                         ConstShadowingMode::ItemStyle,
                         _,
                     ) => {
-                        handler.emit_err(CompileError::MultipleDefinitionsOfConstant {
-                            name: name.clone(),
-                            span: name.span(),
+                        handler.emit_err(CompileError::ConstantDuplicatesConstantOrConfigurable {
+                            existing_constant_or_configurable: "Configurable",
+                            new_constant_or_configurable: "Constant",
+                            name: (&name).into(),
+                            existing_span: configurable_ident.span(),
+                        });
+                    }
+                    // configurable shadowing a constant item-style (outside of a function body)
+                    (
+                        constant_ident,
+                        ConstantDeclaration { .. },
+                        _,
+                        _,
+                        ConfigurableDeclaration { .. },
+                        ConstShadowingMode::ItemStyle,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConstantDuplicatesConstantOrConfigurable {
+                            existing_constant_or_configurable: "Constant",
+                            new_constant_or_configurable: "Configurable",
+                            name: (&name).into(),
+                            existing_span: constant_ident.span(),
                         });
                     }
                     // type or type alias shadowing another type or type alias
@@ -317,6 +461,13 @@ impl Items {
                     const_shadowing_mode,
                     generic_shadowing_mode,
                 ) {
+                    // A general remark for using the `ShadowingSource::LetVar`.
+                    // If the shadowing is detected at this stage, the variable is for
+                    // sure a local variable, because in the case of pattern matching
+                    // struct field variables, the error is already reported and
+                    // the compilation do not proceed to the point of inserting
+                    // the pattern variable into the items.
+
                     // variable shadowing a constant
                     (
                         constant_ident,
@@ -328,10 +479,10 @@ impl Items {
                         _,
                     ) => {
                         handler.emit_err(CompileError::ConstantsCannotBeShadowed {
-                            variable_or_constant: "Variable".to_string(),
+                            shadowing_source: ShadowingSource::LetVar,
                             name: (&name).into(),
                             constant_span: constant_ident.span(),
-                            constant_decl: if is_imported_constant {
+                            constant_decl_span: if is_imported_constant {
                                 decl_engine.get(&constant_decl.decl_id).span.clone()
                             } else {
                                 Span::dummy()
@@ -339,6 +490,14 @@ impl Items {
                             is_alias,
                         });
                     }
+                    // variable shadowing a configurable
+                    (configurable_ident, ConfigurableDecl(_), _, _, VariableDecl { .. }, _, _) => {
+                        handler.emit_err(CompileError::ConfigurablesCannotBeShadowed {
+                            shadowing_source: ShadowingSource::LetVar,
+                            name: (&name).into(),
+                            configurable_span: configurable_ident.span(),
+                        });
+                    }
                     // constant shadowing a constant sequentially
                     (
                         constant_ident,
@@ -350,10 +509,10 @@ impl Items {
                         _,
                     ) => {
                         handler.emit_err(CompileError::ConstantsCannotBeShadowed {
-                            variable_or_constant: "Constant".to_string(),
+                            shadowing_source: ShadowingSource::Const,
                             name: (&name).into(),
                             constant_span: constant_ident.span(),
-                            constant_decl: if is_imported_constant {
+                            constant_decl_span: if is_imported_constant {
                                 decl_engine.get(&constant_decl.decl_id).span.clone()
                             } else {
                                 Span::dummy()
@@ -361,6 +520,22 @@ impl Items {
                             is_alias,
                         });
                     }
+                    // constant shadowing a configurable sequentially
+                    (
+                        configurable_ident,
+                        ConfigurableDecl(_),
+                        _,
+                        _,
+                        ConstantDecl { .. },
+                        ConstShadowingMode::Sequential,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConfigurablesCannotBeShadowed {
+                            shadowing_source: ShadowingSource::Const,
+                            name: (&name).into(),
+                            configurable_span: configurable_ident.span(),
+                        });
+                    }
                     // constant shadowing a variable
                     (_, VariableDecl(variable_decl), _, _, ConstantDecl { .. }, _, _) => {
                         handler.emit_err(CompileError::ConstantShadowsVariable {
@@ -370,17 +545,53 @@ impl Items {
                     }
                     // constant shadowing a constant item-style (outside of a function body)
                     (
+                        constant_ident,
+                        ConstantDecl { .. },
+                        _,
                         _,
                         ConstantDecl { .. },
+                        ConstShadowingMode::ItemStyle,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConstantDuplicatesConstantOrConfigurable {
+                            existing_constant_or_configurable: "Constant",
+                            new_constant_or_configurable: "Constant",
+                            name: (&name).into(),
+                            existing_span: constant_ident.span(),
+                        });
+                    }
+                    // constant shadowing a configurable item-style (outside of a function body)
+                    (
+                        configurable_ident,
+                        ConfigurableDecl { .. },
                         _,
                         _,
                         ConstantDecl { .. },
                         ConstShadowingMode::ItemStyle,
                         _,
                     ) => {
-                        handler.emit_err(CompileError::MultipleDefinitionsOfConstant {
-                            name: name.clone(),
-                            span: name.span(),
+                        handler.emit_err(CompileError::ConstantDuplicatesConstantOrConfigurable {
+                            existing_constant_or_configurable: "Configurable",
+                            new_constant_or_configurable: "Constant",
+                            name: (&name).into(),
+                            existing_span: configurable_ident.span(),
+                        });
+                    }
+                    // configurable shadowing a constant item-style (outside of a function body)
+                    (
+                        constant_ident,
+                        ConstantDecl { .. },
+                        _,
+                        _,
+                        ConfigurableDecl { .. },
+                        ConstShadowingMode::ItemStyle,
+                        _,
+                    ) => {
+                        handler.emit_err(CompileError::ConstantDuplicatesConstantOrConfigurable {
+                            existing_constant_or_configurable: "Constant",
+                            new_constant_or_configurable: "Configurable",
+                            name: (&name).into(),
+                            existing_span: constant_ident.span(),
                         });
                     }
                     // type or type alias shadowing another type or type alias
@@ -464,7 +675,7 @@ impl Items {
             );
         }
 
-        if let Some((ident, (imported_ident, _, decl))) =
+        if let Some((ident, (imported_ident, _, decl, _))) =
             self.use_item_synonyms.get_key_value(&name)
         {
             append_shadowing_error(
@@ -477,6 +688,11 @@ impl Items {
             );
         }
 
+        if collecting_unifications {
+            self.symbols_unique_while_collecting_unifications
+                .write()
+                .insert(name.clone().into(), item.clone());
+        }
         self.symbols.insert(name, item);
 
         Ok(())
@@ -494,43 +710,30 @@ impl Items {
         symbol: Ident,
         src_path: ModulePathBuf,
         decl: &ResolvedDeclaration,
+        visibility: Visibility,
     ) {
         if let Some(cur_decls) = self.use_glob_synonyms.get_mut(&symbol) {
             // Name already bound. Check if the decl is already imported
             let ctx = PartialEqWithEnginesContext::new(engines);
-            match cur_decls.iter().position(|(cur_path, cur_decl)| {
-                cur_decl.eq(decl, &ctx)
-        // For some reason the equality check is not sufficient. In some cases items that
-        // are actually identical fail the eq check, so we have to add heuristics for these
-        // cases.
-        //
-            // These edge occur because core and std preludes are not reexported correctly. Once
-        // reexports are implemented we can handle the preludes correctly, and then these
-        // edge cases should go away.
-        // See https://github.com/FuelLabs/sway/issues/3113
-        //
-        // As a heuristic we replace any bindings from std and core if the new binding is
-        // also from std or core.  This does not work if the user has declared an item with
-        // the same name as an item in one of the preludes, but this is an edge case that we
-        // will have to live with for now.
-                    || ((cur_path[0].as_str() == "core" || cur_path[0].as_str() == "std")
-                        && (src_path[0].as_str() == "core" || src_path[0].as_str() == "std"))
-            }) {
-                Some(index) => {
-                    // The name is already bound to this decl, but
-                    // we need to replace the binding to make the paths work out.
-                    // This appears to be an issue with the core prelude, and will probably no
-                    // longer be necessary once reexports are implemented:
-                    // https://github.com/FuelLabs/sway/issues/3113
-                    cur_decls[index] = (src_path.to_vec(), decl.clone());
+            match cur_decls
+                .iter()
+                .position(|(_cur_path, cur_decl, _cur_visibility)| cur_decl.eq(decl, &ctx))
+            {
+                Some(index) if matches!(visibility, Visibility::Public) => {
+                    // The name is already bound to this decl. If the new symbol is more visible
+                    // than the old one, then replace the old one.
+                    cur_decls[index] = (src_path.to_vec(), decl.clone(), visibility);
+                }
+                Some(_) => {
+                    // Same binding as the existing one. Do nothing.
                 }
                 None => {
                     // New decl for this name. Add it to the end
-                    cur_decls.push((src_path.to_vec(), decl.clone()));
+                    cur_decls.push((src_path.to_vec(), decl.clone(), visibility));
                 }
             }
         } else {
-            let new_vec = vec![(src_path.to_vec(), decl.clone())];
+            let new_vec = vec![(src_path.to_vec(), decl.clone(), visibility)];
             self.use_glob_synonyms.insert(symbol, new_vec);
         }
     }
@@ -545,6 +748,26 @@ impl Items {
             })
     }
 
+    pub(crate) fn check_symbols_unique_while_collecting_unifications(
+        &self,
+        name: &Ident,
+    ) -> Result<ResolvedDeclaration, CompileError> {
+        self.symbols_unique_while_collecting_unifications
+            .read()
+            .get(&name.into())
+            .cloned()
+            .ok_or_else(|| CompileError::SymbolNotFound {
+                name: name.clone(),
+                span: name.span(),
+            })
+    }
+
+    pub(crate) fn clear_symbols_unique_while_collecting_unifications(&self) {
+        self.symbols_unique_while_collecting_unifications
+            .write()
+            .clear();
+    }
+
     pub fn get_items_for_type(
         &self,
         engines: &Engines,
@@ -767,3 +990,26 @@ impl Items {
         Ok((symbol, parent_rover))
     }
 }
+
+fn get_path_for_decl(
+    path: &[sway_types::BaseIdent],
+    decl: &ResolvedDeclaration,
+    engines: &Engines,
+) -> String {
+    let mut path_names = path.iter().map(|x| x.to_string()).collect::<Vec<_>>();
+    // Add the enum name to the path if the decl is an enum variant.
+    match decl {
+        ResolvedDeclaration::Parsed(decl) => {
+            if let Declaration::EnumVariantDeclaration(decl) = decl {
+                let enum_decl = engines.pe().get_enum(&decl.enum_ref);
+                path_names.push(enum_decl.name().to_string())
+            };
+        }
+        ResolvedDeclaration::Typed(decl) => {
+            if let TyDecl::EnumVariantDecl(ty::EnumVariantDecl { enum_ref, .. }) = decl {
+                path_names.push(enum_ref.name().to_string())
+            };
+        }
+    }
+    path_names.join("::")
+}
diff --git a/sway-core/src/semantic_analysis/namespace/mod.rs b/sway-core/src/semantic_analysis/namespace/mod.rs
index ac4aa5082fa..5fba8b2d90e 100644
--- a/sway-core/src/semantic_analysis/namespace/mod.rs
+++ b/sway-core/src/semantic_analysis/namespace/mod.rs
@@ -11,13 +11,14 @@ pub use contract_helpers::*;
 pub use lexical_scope::{Items, LexicalScope, LexicalScopeId, LexicalScopePath};
 pub use module::Module;
 pub use namespace::Namespace;
-pub use namespace::TryInsertingTraitImplOnFailure;
 pub use root::ResolvedDeclaration;
 pub use root::Root;
+pub(super) use trait_map::CodeBlockFirstPass;
 pub(super) use trait_map::IsExtendingExistingImpl;
 pub(super) use trait_map::IsImplSelf;
 pub(super) use trait_map::ResolvedTraitImplItem;
 pub(super) use trait_map::TraitMap;
+pub use trait_map::TryInsertingTraitImplOnFailure;
 
 use sway_types::Ident;
 
diff --git a/sway-core/src/semantic_analysis/namespace/module.rs b/sway-core/src/semantic_analysis/namespace/module.rs
index 327abb91410..77aa192b3be 100644
--- a/sway-core/src/semantic_analysis/namespace/module.rs
+++ b/sway-core/src/semantic_analysis/namespace/module.rs
@@ -7,7 +7,7 @@ use super::{
 };
 
 use rustc_hash::FxHasher;
-use std::hash::BuildHasherDefault;
+use std::{collections::HashMap, hash::BuildHasherDefault};
 use sway_error::handler::Handler;
 use sway_error::{error::CompileError, handler::ErrorEmitted};
 use sway_types::{span::Span, Spanned};
@@ -34,13 +34,15 @@ pub struct Module {
     pub lexical_scopes: Vec<LexicalScope>,
     /// Current lexical scope id in the lexical scope hierarchy stack.
     pub current_lexical_scope_id: LexicalScopeId,
+    /// Maps between a span and the corresponding lexical scope id.
+    pub lexical_scopes_spans: HashMap<Span, LexicalScopeId>,
     /// Name of the module, package name for root module, module name for other modules.
     /// Module name used is the same as declared in `mod name;`.
-    pub name: Option<Ident>,
+    name: Ident,
     /// Whether or not this is a `pub` module
-    pub visibility: Visibility,
+    visibility: Visibility,
     /// Empty span at the beginning of the file implementing the module
-    pub span: Option<Span>,
+    span: Option<Span>,
     /// Indicates whether the module is external to the current package. External modules are
     /// imported in the `Forc.toml` file.
     pub is_external: bool,
@@ -53,20 +55,63 @@ pub struct Module {
 
 impl Default for Module {
     fn default() -> Self {
+        Self::new(Ident::dummy(), Visibility::Public, None)
+    }
+}
+
+impl Module {
+    pub fn new(name: Ident, visibility: Visibility, span: Option<Span>) -> Self {
         Self {
-            visibility: Visibility::Private,
+            visibility,
             submodules: Default::default(),
             lexical_scopes: vec![LexicalScope::default()],
+            lexical_scopes_spans: Default::default(),
             current_lexical_scope_id: 0,
-            name: Default::default(),
-            span: Default::default(),
+            name,
+            span,
             is_external: Default::default(),
             mod_path: Default::default(),
         }
     }
-}
 
-impl Module {
+    // Specialized constructor for cloning Namespace::init. Should not be used for anything else
+    pub(super) fn new_submodule_from_init(
+        &self,
+        name: Ident,
+        visibility: Visibility,
+        span: Option<Span>,
+        is_external: bool,
+        mod_path: ModulePathBuf,
+    ) -> Self {
+        Self {
+            visibility,
+            submodules: self.submodules.clone(),
+            lexical_scopes: self.lexical_scopes.clone(),
+            lexical_scopes_spans: self.lexical_scopes_spans.clone(),
+            current_lexical_scope_id: self.current_lexical_scope_id,
+            name,
+            span,
+            is_external,
+            mod_path,
+        }
+    }
+
+    pub fn name(&self) -> &Ident {
+        &self.name
+    }
+
+    pub fn visibility(&self) -> &Visibility {
+        &self.visibility
+    }
+
+    pub fn span(&self) -> &Option<Span> {
+        &self.span
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        self.span = Some(span);
+    }
+
     pub fn read<R>(&self, _engines: &crate::Engines, mut f: impl FnMut(&Module) -> R) -> R {
         f(self)
     }
@@ -92,6 +137,13 @@ impl Module {
         &self.submodules
     }
 
+    /// Mutable access to this module's submodules.
+    pub fn submodules_mut(
+        &mut self,
+    ) -> &mut im::HashMap<ModuleName, Module, BuildHasherDefault<FxHasher>> {
+        &mut self.submodules
+    }
+
     /// Insert a submodule into this `Module`.
     pub fn insert_submodule(&mut self, name: String, submodule: Module) {
         self.submodules.insert(name, submodule);
@@ -151,8 +203,20 @@ impl Module {
         }
     }
 
+    /// Returns the root lexical scope id associated with this module.
+    pub fn root_lexical_scope_id(&self) -> LexicalScopeId {
+        0
+    }
+
+    /// Returns the root lexical scope associated with this module.
+    pub fn root_lexical_scope(&self) -> &LexicalScope {
+        self.lexical_scopes
+            .get(self.root_lexical_scope_id())
+            .unwrap()
+    }
+
     /// Returns the current lexical scope associated with this module.
-    fn current_lexical_scope(&self) -> &LexicalScope {
+    pub fn current_lexical_scope(&self) -> &LexicalScope {
         self.lexical_scopes
             .get(self.current_lexical_scope_id)
             .unwrap()
@@ -179,19 +243,40 @@ impl Module {
         self.current_lexical_scope_id
     }
 
+    /// Enters the scope with the given span in the module's lexical scope hierarchy.
+    pub fn enter_lexical_scope(
+        &mut self,
+        handler: &Handler,
+        _engines: &Engines,
+        span: Span,
+    ) -> Result<LexicalScopeId, ErrorEmitted> {
+        let id_opt = self.lexical_scopes_spans.get(&span);
+        match id_opt {
+            Some(id) => {
+                self.current_lexical_scope_id = *id;
+                Ok(*id)
+            }
+            None => Err(handler.emit_err(CompileError::Internal(
+                "Could not find a valid lexical scope for this source location.",
+                span.clone(),
+            ))),
+        }
+    }
+
     /// Pushes a new scope to the module's lexical scope hierarchy.
-    pub fn push_new_lexical_scope(&mut self) -> LexicalScopeId {
+    pub fn push_new_lexical_scope(&mut self, span: Span) -> LexicalScopeId {
         let previous_scope_id = self.current_lexical_scope_id();
         let new_scoped_id = {
             self.lexical_scopes.push(LexicalScope {
                 parent: Some(previous_scope_id),
                 ..Default::default()
             });
-            self.current_lexical_scope_id()
+            self.lexical_scopes.len() - 1
         };
         let previous_scope = self.lexical_scopes.get_mut(previous_scope_id).unwrap();
         previous_scope.children.push(new_scoped_id);
         self.current_lexical_scope_id = new_scoped_id;
+        self.lexical_scopes_spans.insert(span, new_scoped_id);
         new_scoped_id
     }
 
diff --git a/sway-core/src/semantic_analysis/namespace/namespace.rs b/sway-core/src/semantic_analysis/namespace/namespace.rs
index cfe52d93d28..6ed7fe8007b 100644
--- a/sway-core/src/semantic_analysis/namespace/namespace.rs
+++ b/sway-core/src/semantic_analysis/namespace/namespace.rs
@@ -7,25 +7,14 @@ use super::{
     module::Module,
     root::{ResolvedDeclaration, Root},
     submodule_namespace::SubmoduleNamespace,
-    trait_map::ResolvedTraitImplItem,
-    ModuleName, ModulePath, ModulePathBuf,
+    ModulePath, ModulePathBuf,
 };
 
-use rustc_hash::FxHasher;
-use std::hash::BuildHasherDefault;
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::span::Span;
 
-/// Enum used to pass a value asking for insertion of type into trait map when an implementation
-/// of the trait cannot be found.
-#[derive(Debug)]
-pub enum TryInsertingTraitImplOnFailure {
-    Yes,
-    No,
-}
-
 /// The set of items that represent the namespace context passed throughout type checking.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct Namespace {
     /// An immutable namespace that consists of the names that should always be present, no matter
     /// what module or scope we are currently checking.
@@ -49,6 +38,14 @@ pub struct Namespace {
 }
 
 impl Namespace {
+    pub fn new() -> Self {
+        Self {
+            init: Module::default(),
+            mod_path: vec![],
+            root: Root::default(),
+        }
+    }
+
     pub fn program_id(&self, engines: &Engines) -> &Module {
         self.root
             .module
@@ -58,7 +55,7 @@ impl Namespace {
 
     /// Initialise the namespace at its root from the given initial namespace.
     /// If the root module contains submodules these are now considered external.
-    pub fn init_root(root: Root) -> Self {
+    pub fn init_root(root: &mut Root) -> Self {
         assert!(
             !root.module.is_external,
             "The root module must not be external during compilation"
@@ -69,32 +66,22 @@ impl Namespace {
         //
         // Every submodule that has been added before calling init_root is now considered
         // external, which we have to enforce at this point.
-        fn clone_with_submodules_external(module: &Module) -> Module {
-            let mut new_submods =
-                im::HashMap::<ModuleName, Module, BuildHasherDefault<FxHasher>>::default();
-            for (name, submod) in module.submodules.iter() {
-                let new_submod = clone_with_submodules_external(submod);
-                new_submods.insert(name.clone(), new_submod);
-            }
-            Module {
-                submodules: new_submods,
-                lexical_scopes: module.lexical_scopes.clone(),
-                current_lexical_scope_id: module.current_lexical_scope_id,
-                name: module.name.clone(),
-                visibility: module.visibility,
-                span: module.span.clone(),
-                is_external: true,
-                mod_path: module.mod_path.clone(),
+        fn set_submodules_external(module: &mut Module) {
+            for (_, submod) in module.submodules_mut().iter_mut() {
+                if !submod.is_external {
+                    submod.is_external = true;
+                    set_submodules_external(submod);
+                }
             }
         }
 
-        let mut init = clone_with_submodules_external(&root.module);
+        set_submodules_external(&mut root.module);
         // The init module itself is not external
-        init.is_external = false;
+        root.module.is_external = false;
 
         Self {
-            init: init.clone(),
-            root: Root { module: init },
+            init: root.module.clone(),
+            root: root.clone(),
             mod_path,
         }
     }
@@ -121,11 +108,6 @@ impl Namespace {
         &self.root.module
     }
 
-    /// The name of the root module
-    pub fn root_module_name(&self) -> &Option<Ident> {
-        &self.root.module.name
-    }
-
     /// Access to the current [Module], i.e. the module at the inner `mod_path`.
     pub fn module(&self, engines: &Engines) -> &Module {
         self.root
@@ -146,7 +128,7 @@ impl Namespace {
         &self,
         handler: &Handler,
         engines: &Engines,
-        path: &[Ident],
+        path: &ModulePath,
     ) -> Result<&Module, ErrorEmitted> {
         self.root.module.lookup_submodule(handler, engines, path)
     }
@@ -170,10 +152,7 @@ impl Namespace {
     ) -> bool {
         // `mod_path` does not contain the root name, so we have to separately check
         // that the root name is equal to the module package name.
-        let root_name = match &self.root.module.name {
-            Some(name) => name,
-            None => panic!("Root module must always have a name."),
-        };
+        let root_name = self.root.module.name();
 
         let (package_name, modules) = absolute_module_path.split_first().expect("Absolute module path must have at least one element, because it always contains the package name.");
 
@@ -204,43 +183,12 @@ impl Namespace {
     /// Returns true if the module given by the `absolute_module_path` is external
     /// to the current package. External modules are imported in the `Forc.toml` file.
     pub(crate) fn module_is_external(&self, absolute_module_path: &ModulePath) -> bool {
-        let root_name = match &self.root.module.name {
-            Some(name) => name,
-            None => panic!("Root module must always have a name."),
-        };
+        let root_name = self.root.module.name();
 
         assert!(!absolute_module_path.is_empty(), "Absolute module path must have at least one element, because it always contains the package name.");
 
         root_name != &absolute_module_path[0]
     }
-
-    pub fn get_root_trait_item_for_type(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        name: &Ident,
-        type_id: TypeId,
-        as_trait: Option<CallPath>,
-    ) -> Result<ResolvedTraitImplItem, ErrorEmitted> {
-        self.root
-            .module
-            .current_items()
-            .implemented_traits
-            .get_trait_item_for_type(handler, engines, name, type_id, as_trait)
-    }
-
-    pub fn resolve_root_symbol(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        mod_path: &ModulePath,
-        symbol: &Ident,
-        self_type: Option<TypeId>,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        self.root
-            .resolve_symbol(handler, engines, mod_path, symbol, self_type)
-    }
-
     /// Short-hand for calling [Root::resolve_symbol] on `root` with the `mod_path`.
     pub(crate) fn resolve_symbol(
         &self,
@@ -304,24 +252,23 @@ impl Namespace {
     ) -> SubmoduleNamespace {
         let init = self.init.clone();
         let is_external = self.module(engines).is_external;
-        self.module_mut(engines)
-            .submodules
-            .entry(mod_name.to_string())
-            .or_insert(init);
         let submod_path: Vec<_> = self
             .mod_path
             .iter()
             .cloned()
             .chain(Some(mod_name.clone()))
             .collect();
+        self.module_mut(engines)
+            .submodules
+            .entry(mod_name.to_string())
+            .or_insert(init.new_submodule_from_init(
+                mod_name,
+                visibility,
+                Some(module_span),
+                is_external,
+                submod_path.clone(),
+            ));
         let parent_mod_path = std::mem::replace(&mut self.mod_path, submod_path.clone());
-        // self.module() now refers to a different module, so refetch
-        let new_module = self.module_mut(engines);
-        new_module.name = Some(mod_name);
-        new_module.span = Some(module_span);
-        new_module.visibility = visibility;
-        new_module.is_external = is_external;
-        new_module.mod_path = submod_path;
         SubmoduleNamespace {
             namespace: self,
             parent_mod_path,
@@ -329,23 +276,17 @@ impl Namespace {
     }
 
     /// Pushes a new submodule to the namespace's module hierarchy.
-    pub fn push_new_submodule(
+    pub fn push_submodule(
         &mut self,
         engines: &Engines,
         mod_name: Ident,
         visibility: Visibility,
         module_span: Span,
     ) {
-        let module = Module {
-            name: Some(mod_name.clone()),
-            visibility,
-            span: Some(module_span),
-            ..Default::default()
-        };
         self.module_mut(engines)
             .submodules
             .entry(mod_name.to_string())
-            .or_insert(module);
+            .or_insert(Module::new(mod_name.clone(), visibility, Some(module_span)));
         self.mod_path.push(mod_name);
     }
 
diff --git a/sway-core/src/semantic_analysis/namespace/root.rs b/sway-core/src/semantic_analysis/namespace/root.rs
index 555efb33801..7d4e22b7265 100644
--- a/sway-core/src/semantic_analysis/namespace/root.rs
+++ b/sway-core/src/semantic_analysis/namespace/root.rs
@@ -1,22 +1,23 @@
 use std::fmt;
 
-use super::{module::Module, namespace::Namespace, Ident, ResolvedTraitImplItem};
+use super::{module::Module, trait_map::TraitMap, Ident};
 use crate::{
-    decl_engine::DeclRef,
+    decl_engine::{DeclEngine, DeclRef},
     engine_threading::*,
     language::{
         parsed::*,
-        ty::{self, TyDecl, TyTraitItem},
+        ty::{self, StructDecl, TyDecl},
         CallPath, Visibility,
     },
-    namespace::ModulePath,
-    TypeId, TypeInfo,
+    namespace::{ModulePath, ModulePathBuf},
+    semantic_analysis::type_resolve::{resolve_associated_item, resolve_associated_type},
+    TypeId,
 };
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
 };
-use sway_types::{Named, Spanned};
+use sway_types::Spanned;
 use sway_utils::iter_prefixes;
 
 #[derive(Clone, Debug)]
@@ -60,6 +61,22 @@ impl PartialEqWithEngines for ResolvedDeclaration {
 }
 
 impl ResolvedDeclaration {
+    pub fn is_typed(&self) -> bool {
+        match self {
+            ResolvedDeclaration::Parsed(_) => false,
+            ResolvedDeclaration::Typed(_) => true,
+        }
+    }
+
+    pub fn resolve_parsed(self, decl_engine: &DeclEngine) -> Declaration {
+        match self {
+            ResolvedDeclaration::Parsed(decl) => decl,
+            ResolvedDeclaration::Typed(ty_decl) => ty_decl
+                .get_parsed_decl(decl_engine)
+                .expect("expecting valid parsed declaration"),
+        }
+    }
+
     pub fn expect_parsed(self) -> Declaration {
         match self {
             ResolvedDeclaration::Parsed(decl) => decl,
@@ -81,12 +98,56 @@ impl ResolvedDeclaration {
         }
     }
 
+    pub(crate) fn to_struct_decl(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
+        match self {
+            ResolvedDeclaration::Parsed(decl) => decl
+                .to_struct_decl(handler, engines)
+                .map(|id| ResolvedDeclaration::Parsed(Declaration::StructDeclaration(id))),
+            ResolvedDeclaration::Typed(decl) => decl.to_struct_decl(handler, engines).map(|id| {
+                ResolvedDeclaration::Typed(TyDecl::StructDecl(StructDecl { decl_id: id }))
+            }),
+        }
+    }
+
     pub(crate) fn visibility(&self, engines: &Engines) -> Visibility {
         match self {
             ResolvedDeclaration::Parsed(decl) => decl.visibility(engines.pe()),
             ResolvedDeclaration::Typed(decl) => decl.visibility(engines.de()),
         }
     }
+
+    fn span(&self, engines: &Engines) -> sway_types::Span {
+        match self {
+            ResolvedDeclaration::Parsed(decl) => decl.span(engines),
+            ResolvedDeclaration::Typed(decl) => decl.span(engines),
+        }
+    }
+
+    pub(crate) fn return_type(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+    ) -> Result<TypeId, ErrorEmitted> {
+        match self {
+            ResolvedDeclaration::Parsed(_decl) => unreachable!(),
+            ResolvedDeclaration::Typed(decl) => decl.return_type(handler, engines),
+        }
+    }
+
+    fn is_trait(&self) -> bool {
+        match self {
+            ResolvedDeclaration::Parsed(decl) => {
+                matches!(decl, Declaration::TraitDeclaration(_))
+            }
+            ResolvedDeclaration::Typed(decl) => {
+                matches!(decl, TyDecl::TraitDecl(_))
+            }
+        }
+    }
 }
 
 /// The root module, from which all other modules can be accessed.
@@ -97,7 +158,7 @@ impl ResolvedDeclaration {
 /// canonical paths, or that use canonical paths internally, are *only* called from the root. This
 /// normally includes methods that first lookup some canonical path via `use_synonyms` before using
 /// that canonical path to look up the symbol declaration.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct Root {
     pub(crate) module: Module,
 }
@@ -111,38 +172,89 @@ impl Root {
     /// This is used when an import path contains an asterisk.
     ///
     /// Paths are assumed to be absolute.
-    pub(crate) fn star_import(
+    pub fn star_import(
         &mut self,
         handler: &Handler,
         engines: &Engines,
         src: &ModulePath,
         dst: &ModulePath,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
-        self.check_module_privacy(handler, engines, src)?;
+        self.check_module_privacy(handler, engines, src, dst)?;
 
         let src_mod = self.module.lookup_submodule(handler, engines, src)?;
-        let implemented_traits = src_mod.current_items().implemented_traits.clone();
-        let mut symbols_and_decls = vec![];
+
+        let mut decls_and_item_imports = vec![];
+
+        let get_path = |mod_path: Vec<Ident>| {
+            let mut is_external = false;
+            if let Some(submodule) = src_mod.submodule(engines, &[mod_path[0].clone()]) {
+                is_external = submodule.is_external
+            };
+
+            let mut path = src[..1].to_vec();
+            if is_external {
+                path = mod_path;
+            } else {
+                path.extend(mod_path);
+            }
+
+            path
+        };
+
+        // Collect all items declared in the source module
         for (symbol, decl) in src_mod.current_items().symbols.iter() {
             if is_ancestor(src, dst) || decl.visibility(engines).is_public() {
-                symbols_and_decls.push((symbol.clone(), decl.clone()));
+                decls_and_item_imports.push((symbol.clone(), decl.clone(), src.to_vec()));
+            }
+        }
+        // Collect those item-imported items that the source module reexports
+        // These live in the same namespace as local declarations, so no shadowing is possible
+        for (symbol, (_, path, decl, src_visibility)) in
+            src_mod.current_items().use_item_synonyms.iter()
+        {
+            if src_visibility.is_public() {
+                decls_and_item_imports.push((symbol.clone(), decl.clone(), get_path(path.clone())))
             }
         }
 
+        // Collect those glob-imported items that the source module reexports. These may be shadowed
+        // by local declarations and item imports in the source module, so they are treated
+        // separately.
+        let mut glob_imports = vec![];
+        for (symbol, bindings) in src_mod.current_items().use_glob_synonyms.iter() {
+            // Ignore if the symbol is shadowed by a local declaration or an item import in the source module
+            if !decls_and_item_imports
+                .iter()
+                .any(|(other_symbol, _, _)| symbol == other_symbol)
+            {
+                for (path, decl, src_visibility) in bindings.iter() {
+                    if src_visibility.is_public() {
+                        glob_imports.push((symbol.clone(), decl.clone(), get_path(path.clone())))
+                    }
+                }
+            }
+        }
+
+        let implemented_traits = src_mod.current_items().implemented_traits.clone();
         let dst_mod = self.module.lookup_submodule_mut(handler, engines, dst)?;
         dst_mod
             .current_items_mut()
             .implemented_traits
             .extend(implemented_traits, engines);
 
-        symbols_and_decls.iter().for_each(|(symbol, decl)| {
-            dst_mod.current_items_mut().insert_glob_use_symbol(
-                engines,
-                symbol.clone(),
-                src.to_vec(),
-                decl,
-            )
-        });
+        decls_and_item_imports
+            .iter()
+            .chain(glob_imports.iter())
+            .for_each(|(symbol, decl, path)| {
+                dst_mod.current_items_mut().insert_glob_use_symbol(
+                    engines,
+                    symbol.clone(),
+                    path.clone(),
+                    decl,
+                    visibility,
+                )
+            });
 
         Ok(())
     }
@@ -158,9 +270,77 @@ impl Root {
         src: &ModulePath,
         dst: &ModulePath,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let (last_item, src) = src.split_last().expect("guaranteed by grammar");
-        self.item_import(handler, engines, src, last_item, dst, alias)
+        self.item_import(handler, engines, src, last_item, dst, alias, visibility)
+    }
+
+    fn item_lookup(
+        &self,
+        handler: &Handler,
+        engines: &Engines,
+        item: &Ident,
+        src: &ModulePath,
+        dst: &ModulePath,
+    ) -> Result<(ResolvedDeclaration, ModulePathBuf), ErrorEmitted> {
+        let src_mod = self.module.lookup_submodule(handler, engines, src)?;
+        let src_items = src_mod.current_items();
+
+        let (decl, path, src_visibility) = if let Some(decl) = src_items.symbols.get(item) {
+            let visibility = if is_ancestor(src, dst) {
+                Visibility::Public
+            } else {
+                decl.visibility(engines)
+            };
+            (decl.clone(), src.to_vec(), visibility)
+        } else if let Some((_, path, decl, reexport)) = src_items.use_item_synonyms.get(item) {
+            (decl.clone(), path.clone(), *reexport)
+        } else if let Some(decls) = src_items.use_glob_synonyms.get(item) {
+            if decls.len() == 1 {
+                let (path, decl, reexport) = &decls[0];
+                (decl.clone(), path.clone(), *reexport)
+            } else if decls.is_empty() {
+                return Err(handler.emit_err(CompileError::Internal(
+            "The name {symbol} was bound in a star import, but no corresponding module paths were found",
+            item.span(),
+                    )));
+            } else {
+                return Err(handler.emit_err(CompileError::SymbolWithMultipleBindings {
+                    name: item.clone(),
+                    paths: decls
+                        .iter()
+                        .map(|(path, decl, _)| {
+                            let mut path_strs = path.iter().map(|x| x.as_str()).collect::<Vec<_>>();
+                            // Add the enum name to the path if the decl is an enum variant.
+                            if let TyDecl::EnumVariantDecl(ty::EnumVariantDecl {
+                                enum_ref, ..
+                            }) = decl.expect_typed_ref()
+                            {
+                                path_strs.push(enum_ref.name().as_str())
+                            };
+                            path_strs.join("::")
+                        })
+                        .collect(),
+                    span: item.span(),
+                }));
+            }
+        } else {
+            // Symbol not found
+            return Err(handler.emit_err(CompileError::SymbolNotFound {
+                name: item.clone(),
+                span: item.span(),
+            }));
+        };
+
+        if !src_visibility.is_public() {
+            handler.emit_err(CompileError::ImportPrivateSymbol {
+                name: item.clone(),
+                span: item.span(),
+            });
+        }
+
+        Ok((decl, path))
     }
 
     /// Pull a single `item` from the given `src` module and import it into the `dst` module.
@@ -175,52 +355,77 @@ impl Root {
         item: &Ident,
         dst: &ModulePath,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
-        self.check_module_privacy(handler, engines, src)?;
-
+        self.check_module_privacy(handler, engines, src, dst)?;
         let src_mod = self.module.lookup_submodule(handler, engines, src)?;
-        match src_mod.current_items().symbols.get(item).cloned() {
-            Some(decl) => {
-                if !decl.visibility(engines).is_public() && !is_ancestor(src, dst) {
-                    handler.emit_err(CompileError::ImportPrivateSymbol {
-                        name: item.clone(),
-                        span: item.span(),
-                    });
-                }
 
-                // no matter what, import it this way though.
-                let dst_mod = self.module.lookup_submodule_mut(handler, engines, dst)?;
-                let check_name_clash = |name| {
-                    if let Some((_, _, _)) = dst_mod.current_items().use_item_synonyms.get(name) {
-                        handler.emit_err(CompileError::ShadowsOtherSymbol { name: name.into() });
-                    }
-                };
-
-                match alias {
-                    Some(alias) => {
-                        check_name_clash(&alias);
-                        dst_mod
-                            .current_items_mut()
-                            .use_item_synonyms
-                            .insert(alias.clone(), (Some(item.clone()), src.to_vec(), decl))
-                    }
-                    None => {
-                        check_name_clash(item);
-                        dst_mod
-                            .current_items_mut()
-                            .use_item_synonyms
-                            .insert(item.clone(), (None, src.to_vec(), decl))
-                    }
-                };
+        let (decl, path) = self.item_lookup(handler, engines, item, src, dst)?;
+
+        let mut impls_to_insert = TraitMap::default();
+        if decl.is_typed() {
+            // We only handle trait imports when handling typed declarations,
+            // that is, when performing type-checking, and not when collecting.
+            // Update this once the type system is updated to refer to parsed
+            // declarations.
+            //  if this is an enum or struct or function, import its implementations
+            if let Ok(type_id) = decl.return_type(&Handler::default(), engines) {
+                impls_to_insert.extend(
+                    src_mod
+                        .current_items()
+                        .implemented_traits
+                        .filter_by_type_item_import(
+                            type_id,
+                            engines,
+                            super::CodeBlockFirstPass::No,
+                        ),
+                    engines,
+                );
+            }
+            // if this is a trait, import its implementations
+            let decl_span = decl.span(engines);
+            if decl.is_trait() {
+                // TODO: we only import local impls from the source namespace
+                // this is okay for now but we'll need to device some mechanism to collect all available trait impls
+                impls_to_insert.extend(
+                    src_mod
+                        .current_items()
+                        .implemented_traits
+                        .filter_by_trait_decl_span(decl_span),
+                    engines,
+                );
+            }
+        }
+
+        // no matter what, import it this way though.
+        let dst_mod = self.module.lookup_submodule_mut(handler, engines, dst)?;
+        let check_name_clash = |name| {
+            if dst_mod.current_items().use_item_synonyms.contains_key(name) {
+                handler.emit_err(CompileError::ShadowsOtherSymbol { name: name.into() });
+            }
+        };
+        match alias {
+            Some(alias) => {
+                check_name_clash(&alias);
+                dst_mod
+                    .current_items_mut()
+                    .use_item_synonyms
+                    .insert(alias.clone(), (Some(item.clone()), path, decl, visibility))
             }
             None => {
-                return Err(handler.emit_err(CompileError::SymbolNotFound {
-                    name: item.clone(),
-                    span: item.span(),
-                }));
+                check_name_clash(item);
+                dst_mod
+                    .current_items_mut()
+                    .use_item_synonyms
+                    .insert(item.clone(), (None, path, decl, visibility))
             }
         };
 
+        dst_mod
+            .current_items_mut()
+            .implemented_traits
+            .extend(impls_to_insert, engines);
+
         Ok(())
     }
 
@@ -237,22 +442,85 @@ impl Root {
         variant_name: &Ident,
         dst: &ModulePath,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
-        self.check_module_privacy(handler, engines, src)?;
+        self.check_module_privacy(handler, engines, src, dst)?;
 
         let decl_engine = engines.de();
+        let parsed_decl_engine = engines.pe();
 
-        let src_mod = self.module.lookup_submodule(handler, engines, src)?;
-        match src_mod.current_items().symbols.get(enum_name).cloned() {
-            Some(decl) => {
-                if !decl.visibility(engines).is_public() && !is_ancestor(src, dst) {
-                    handler.emit_err(CompileError::ImportPrivateSymbol {
-                        name: enum_name.clone(),
-                        span: enum_name.span(),
-                    });
-                }
+        let (decl, path) = self.item_lookup(handler, engines, enum_name, src, dst)?;
+
+        match decl {
+            ResolvedDeclaration::Parsed(decl) => {
+                if let Declaration::EnumDeclaration(decl_id) = decl {
+                    let enum_decl = parsed_decl_engine.get_enum(&decl_id);
+
+                    if let Some(variant_decl) =
+                        enum_decl.variants.iter().find(|v| v.name == *variant_name)
+                    {
+                        // import it this way.
+                        let dst_mod = self.module.lookup_submodule_mut(handler, engines, dst)?;
+                        let check_name_clash = |name| {
+                            if dst_mod.current_items().use_item_synonyms.contains_key(name) {
+                                handler.emit_err(CompileError::ShadowsOtherSymbol {
+                                    name: name.into(),
+                                });
+                            }
+                        };
 
-                if let TyDecl::EnumDecl(ty::EnumDecl { decl_id, .. }) = decl.expect_typed() {
+                        match alias {
+                            Some(alias) => {
+                                check_name_clash(&alias);
+                                dst_mod.current_items_mut().use_item_synonyms.insert(
+                                    alias.clone(),
+                                    (
+                                        Some(variant_name.clone()),
+                                        path,
+                                        ResolvedDeclaration::Parsed(
+                                            Declaration::EnumVariantDeclaration(
+                                                EnumVariantDeclaration {
+                                                    enum_ref: decl_id,
+                                                    variant_name: variant_name.clone(),
+                                                    variant_decl_span: variant_decl.span.clone(),
+                                                },
+                                            ),
+                                        ),
+                                        visibility,
+                                    ),
+                                );
+                            }
+                            None => {
+                                check_name_clash(variant_name);
+                                dst_mod.current_items_mut().use_item_synonyms.insert(
+                                    variant_name.clone(),
+                                    (
+                                        None,
+                                        path,
+                                        ResolvedDeclaration::Parsed(
+                                            Declaration::EnumVariantDeclaration(
+                                                EnumVariantDeclaration {
+                                                    enum_ref: decl_id,
+                                                    variant_name: variant_name.clone(),
+                                                    variant_decl_span: variant_decl.span.clone(),
+                                                },
+                                            ),
+                                        ),
+                                        visibility,
+                                    ),
+                                );
+                            }
+                        };
+                    } else {
+                        return Err(handler.emit_err(CompileError::SymbolNotFound {
+                            name: variant_name.clone(),
+                            span: variant_name.span(),
+                        }));
+                    }
+                }
+            }
+            ResolvedDeclaration::Typed(decl) => {
+                if let TyDecl::EnumDecl(ty::EnumDecl { decl_id, .. }) = decl {
                     let enum_decl = decl_engine.get_enum(&decl_id);
                     let enum_ref = DeclRef::new(
                         enum_decl.call_path.suffix.clone(),
@@ -272,6 +540,7 @@ impl Root {
                                 });
                             }
                         };
+
                         match alias {
                             Some(alias) => {
                                 check_name_clash(&alias);
@@ -279,7 +548,7 @@ impl Root {
                                     alias.clone(),
                                     (
                                         Some(variant_name.clone()),
-                                        src.to_vec(),
+                                        path,
                                         ResolvedDeclaration::Typed(TyDecl::EnumVariantDecl(
                                             ty::EnumVariantDecl {
                                                 enum_ref: enum_ref.clone(),
@@ -287,6 +556,7 @@ impl Root {
                                                 variant_decl_span: variant_decl.span.clone(),
                                             },
                                         )),
+                                        visibility,
                                     ),
                                 );
                             }
@@ -296,7 +566,7 @@ impl Root {
                                     variant_name.clone(),
                                     (
                                         None,
-                                        src.to_vec(),
+                                        path,
                                         ResolvedDeclaration::Typed(TyDecl::EnumVariantDecl(
                                             ty::EnumVariantDecl {
                                                 enum_ref: enum_ref.clone(),
@@ -304,6 +574,7 @@ impl Root {
                                                 variant_decl_span: variant_decl.span.clone(),
                                             },
                                         )),
+                                        visibility,
                                     ),
                                 );
                             }
@@ -321,12 +592,6 @@ impl Root {
                     )));
                 }
             }
-            None => {
-                return Err(handler.emit_err(CompileError::SymbolNotFound {
-                    name: enum_name.clone(),
-                    span: enum_name.span(),
-                }));
-            }
         };
 
         Ok(())
@@ -342,185 +607,79 @@ impl Root {
         src: &ModulePath,
         dst: &ModulePath,
         enum_name: &Ident,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
-        self.check_module_privacy(handler, engines, src)?;
+        self.check_module_privacy(handler, engines, src, dst)?;
 
         let parsed_decl_engine = engines.pe();
         let decl_engine = engines.de();
 
-        let src_mod = self.module.lookup_submodule(handler, engines, src)?;
-        let resolved_decl = src_mod.current_items().symbols.get(enum_name).cloned();
-
-        match resolved_decl {
-            Some(decl) => {
-                if !decl.visibility(engines).is_public() && !is_ancestor(src, dst) {
-                    handler.emit_err(CompileError::ImportPrivateSymbol {
-                        name: enum_name.clone(),
-                        span: enum_name.span(),
-                    });
-                }
-
-                if let ResolvedDeclaration::Parsed(Declaration::EnumDeclaration(decl_id)) = decl {
-                    let enum_decl = parsed_decl_engine.get_enum(&decl_id);
-
-                    for variant in enum_decl.variants.iter() {
-                        let variant_name = &variant.name;
-                        let variant_decl =
-                            Declaration::EnumVariantDeclaration(EnumVariantDeclaration {
-                                enum_ref: decl_id,
-                                variant_name: variant_name.clone(),
-                                variant_decl_span: variant.span.clone(),
-                            });
-
-                        // import it this way.
-                        self.module
-                            .lookup_submodule_mut(handler, engines, dst)?
-                            .current_items_mut()
-                            .insert_glob_use_symbol(
-                                engines,
-                                variant_name.clone(),
-                                src.to_vec(),
-                                &ResolvedDeclaration::Parsed(variant_decl),
-                            );
-                    }
-                } else if let ResolvedDeclaration::Typed(TyDecl::EnumDecl(ty::EnumDecl {
-                    decl_id,
-                    ..
-                })) = decl
-                {
-                    let enum_decl = decl_engine.get_enum(&decl_id);
-                    let enum_ref = DeclRef::new(
-                        enum_decl.call_path.suffix.clone(),
-                        decl_id,
-                        enum_decl.span(),
-                    );
-
-                    for variant_decl in enum_decl.variants.iter() {
-                        let variant_name = &variant_decl.name;
-                        let decl = ResolvedDeclaration::Typed(TyDecl::EnumVariantDecl(
-                            ty::EnumVariantDecl {
-                                enum_ref: enum_ref.clone(),
-                                variant_name: variant_name.clone(),
-                                variant_decl_span: variant_decl.span.clone(),
-                            },
-                        ));
+        let (decl, path) = self.item_lookup(handler, engines, enum_name, src, dst)?;
 
-                        // import it this way.
-                        self.module
-                            .lookup_submodule_mut(handler, engines, dst)?
-                            .current_items_mut()
-                            .insert_glob_use_symbol(
-                                engines,
-                                variant_name.clone(),
-                                src.to_vec(),
-                                &decl,
-                            );
-                    }
-                } else {
-                    return Err(handler.emit_err(CompileError::Internal(
-                        "Attempting to import variants of something that isn't an enum",
-                        enum_name.span(),
-                    )));
+        match decl {
+            ResolvedDeclaration::Parsed(Declaration::EnumDeclaration(decl_id)) => {
+                let enum_decl = parsed_decl_engine.get_enum(&decl_id);
+
+                for variant in enum_decl.variants.iter() {
+                    let variant_name = &variant.name;
+                    let variant_decl =
+                        Declaration::EnumVariantDeclaration(EnumVariantDeclaration {
+                            enum_ref: decl_id,
+                            variant_name: variant_name.clone(),
+                            variant_decl_span: variant.span.clone(),
+                        });
+
+                    // import it this way.
+                    self.module
+                        .lookup_submodule_mut(handler, engines, dst)?
+                        .current_items_mut()
+                        .insert_glob_use_symbol(
+                            engines,
+                            variant_name.clone(),
+                            path.clone(),
+                            &ResolvedDeclaration::Parsed(variant_decl),
+                            visibility,
+                        );
                 }
             }
-            None => {
-                return Err(handler.emit_err(CompileError::SymbolNotFound {
-                    name: enum_name.clone(),
-                    span: enum_name.span(),
-                }));
-            }
-        };
-
-        Ok(())
-    }
-
-    /// Given a path to a `src` module, create synonyms to every symbol in that module to the given
-    /// `dst` module.
-    ///
-    /// This is used when an import path contains an asterisk.
-    ///
-    /// Paths are assumed to be absolute.
-    pub fn star_import_with_reexports(
-        &mut self,
-        handler: &Handler,
-        engines: &Engines,
-        src: &ModulePath,
-        dst: &ModulePath,
-    ) -> Result<(), ErrorEmitted> {
-        self.check_module_privacy(handler, engines, src)?;
-
-        let src_mod = self.module.lookup_submodule(handler, engines, src)?;
-
-        let implemented_traits = src_mod.current_items().implemented_traits.clone();
-        let use_item_synonyms = src_mod.current_items().use_item_synonyms.clone();
-        let use_glob_synonyms = src_mod.current_items().use_glob_synonyms.clone();
+            ResolvedDeclaration::Typed(TyDecl::EnumDecl(ty::EnumDecl { decl_id, .. })) => {
+                let enum_decl = decl_engine.get_enum(&decl_id);
+                let enum_ref = DeclRef::new(
+                    enum_decl.call_path.suffix.clone(),
+                    decl_id,
+                    enum_decl.span(),
+                );
+
+                for variant_decl in enum_decl.variants.iter() {
+                    let variant_name = &variant_decl.name;
+                    let decl =
+                        ResolvedDeclaration::Typed(TyDecl::EnumVariantDecl(ty::EnumVariantDecl {
+                            enum_ref: enum_ref.clone(),
+                            variant_name: variant_name.clone(),
+                            variant_decl_span: variant_decl.span.clone(),
+                        }));
 
-        // collect all declared and reexported symbols from the source module
-        let mut all_symbols_and_decls: Vec<(Ident, ResolvedDeclaration)> = vec![];
-        for (symbol, decls) in src_mod.current_items().use_glob_synonyms.iter() {
-            decls
-                .iter()
-                .for_each(|(_, decl)| all_symbols_and_decls.push((symbol.clone(), decl.clone())));
-        }
-        for (symbol, (_, _, decl)) in src_mod.current_items().use_item_synonyms.iter() {
-            all_symbols_and_decls.push((symbol.clone(), decl.clone()));
-        }
-        for (symbol, decl) in src_mod.current_items().symbols.iter() {
-            if is_ancestor(src, dst) || decl.visibility(engines).is_public() {
-                all_symbols_and_decls.push((symbol.clone(), decl.clone()));
+                    // import it this way.
+                    self.module
+                        .lookup_submodule_mut(handler, engines, dst)?
+                        .current_items_mut()
+                        .insert_glob_use_symbol(
+                            engines,
+                            variant_name.clone(),
+                            path.clone(),
+                            &decl,
+                            visibility,
+                        );
+                }
             }
-        }
-
-        let mut symbols_paths_and_decls = vec![];
-        let get_path = |mod_path: Vec<Ident>| {
-            let mut is_external = false;
-            if let Some(submodule) = src_mod.submodule(engines, &[mod_path[0].clone()]) {
-                is_external = submodule.is_external
-            };
-
-            let mut path = src[..1].to_vec();
-            if is_external {
-                path = mod_path;
-            } else {
-                path.extend(mod_path);
+            _ => {
+                return Err(handler.emit_err(CompileError::Internal(
+                    "Attempting to import variants of something that isn't an enum",
+                    enum_name.span(),
+                )));
             }
-
-            path
         };
 
-        for (symbol, (_, mod_path, decl)) in use_item_synonyms {
-            symbols_paths_and_decls.push((symbol, get_path(mod_path), decl));
-        }
-        for (symbol, decls) in use_glob_synonyms {
-            decls.iter().for_each(|(mod_path, decl)| {
-                symbols_paths_and_decls.push((
-                    symbol.clone(),
-                    get_path(mod_path.clone()),
-                    decl.clone(),
-                ))
-            });
-        }
-
-        let dst_mod = self.module.lookup_submodule_mut(handler, engines, dst)?;
-        dst_mod
-            .current_items_mut()
-            .implemented_traits
-            .extend(implemented_traits, engines);
-
-        let mut try_add = |symbol, path, decl: ResolvedDeclaration| {
-            dst_mod
-                .current_items_mut()
-                .insert_glob_use_symbol(engines, symbol, path, &decl);
-        };
-
-        for (symbol, decl) in all_symbols_and_decls {
-            try_add(symbol.clone(), src.to_vec(), decl);
-        }
-
-        for (symbol, path, decl) in symbols_paths_and_decls {
-            try_add(symbol.clone(), path, decl);
-        }
-
         Ok(())
     }
 
@@ -529,14 +688,14 @@ impl Root {
         handler: &Handler,
         engines: &Engines,
         src: &ModulePath,
+        dst: &ModulePath,
     ) -> Result<(), ErrorEmitted> {
-        let dst = self.module.mod_path();
         // you are always allowed to access your ancestor's symbols
         if !is_ancestor(src, dst) {
             // we don't check the first prefix because direct children are always accessible
             for prefix in iter_prefixes(src).skip(1) {
                 let module = self.module.lookup_submodule(handler, engines, prefix)?;
-                if module.visibility.is_private() {
+                if module.visibility().is_private() {
                     let prefix_last = prefix[prefix.len() - 1].clone();
                     handler.emit_err(CompileError::ImportPrivateModule {
                         span: prefix_last.span(),
@@ -574,7 +733,7 @@ impl Root {
         mod_path: &ModulePath,
         call_path: &CallPath,
         self_type: Option<TypeId>,
-    ) -> Result<(ResolvedDeclaration, Vec<Ident>), ErrorEmitted> {
+    ) -> Result<(ResolvedDeclaration, ModulePathBuf), ErrorEmitted> {
         let symbol_path: Vec<_> = mod_path
             .iter()
             .chain(&call_path.prefixes)
@@ -589,74 +748,6 @@ impl Root {
         )
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn resolve_call_path_and_root_type_id(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        module: &Module,
-        root_type_id: TypeId,
-        mut as_trait: Option<CallPath>,
-        call_path: &CallPath,
-        self_type: Option<TypeId>,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        // This block tries to resolve associated types
-        let mut decl_opt = None;
-        let mut type_id_opt = Some(root_type_id);
-        for ident in call_path.prefixes.iter() {
-            if let Some(type_id) = type_id_opt {
-                type_id_opt = None;
-                decl_opt = Some(self.resolve_associated_type_from_type_id(
-                    handler,
-                    engines,
-                    module,
-                    ident,
-                    type_id,
-                    as_trait.clone(),
-                    self_type,
-                )?);
-                as_trait = None;
-            } else if let Some(decl) = decl_opt {
-                decl_opt = Some(self.resolve_associated_type(
-                    handler,
-                    engines,
-                    module,
-                    ident,
-                    decl,
-                    as_trait.clone(),
-                    self_type,
-                )?);
-                as_trait = None;
-            }
-        }
-        if let Some(type_id) = type_id_opt {
-            let decl = self.resolve_associated_type_from_type_id(
-                handler,
-                engines,
-                module,
-                &call_path.suffix,
-                type_id,
-                as_trait,
-                self_type,
-            )?;
-            return Ok(decl);
-        }
-        if let Some(decl) = decl_opt {
-            let decl = self.resolve_associated_item(
-                handler,
-                engines,
-                module,
-                &call_path.suffix,
-                decl,
-                as_trait,
-                self_type,
-            )?;
-            Ok(decl)
-        } else {
-            Err(handler.emit_err(CompileError::Internal("Unexpected error", call_path.span())))
-        }
-    }
-
     /// Given a path to a module and the identifier of a symbol within that module, resolve its
     /// declaration.
     ///
@@ -689,7 +780,7 @@ impl Root {
         let mut decl_opt = None;
         for ident in mod_path.iter() {
             if let Some(decl) = decl_opt {
-                decl_opt = Some(self.resolve_associated_type(
+                decl_opt = Some(resolve_associated_type(
                     handler, engines, module, ident, decl, None, self_type,
                 )?);
             } else {
@@ -699,242 +790,32 @@ impl Root {
                         current_mod_path.push(ident.clone());
                     }
                     None => {
-                        decl_opt =
-                            Some(self.resolve_symbol_helper(handler, engines, ident, module)?);
+                        decl_opt = Some(
+                            module
+                                .current_lexical_scope()
+                                .items
+                                .resolve_symbol(handler, engines, ident)?,
+                        );
                     }
                 }
             }
         }
         if let Some(decl) = decl_opt {
-            let decl = self
-                .resolve_associated_item(handler, engines, module, symbol, decl, None, self_type)?;
+            let decl =
+                resolve_associated_item(handler, engines, module, symbol, decl, None, self_type)?;
             return Ok((decl, current_mod_path));
         }
 
         self.module
             .lookup_submodule(handler, engines, mod_path)
             .and_then(|module| {
-                let decl = self.resolve_symbol_helper(handler, engines, symbol, module)?;
+                let decl = module
+                    .current_lexical_scope()
+                    .items
+                    .resolve_symbol(handler, engines, symbol)?;
                 Ok((decl, mod_path.to_vec()))
             })
     }
-
-    #[allow(clippy::too_many_arguments)]
-    fn resolve_associated_type(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        module: &Module,
-        symbol: &Ident,
-        decl: ResolvedDeclaration,
-        as_trait: Option<CallPath>,
-        self_type: Option<TypeId>,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        let type_info = self.decl_to_type_info(handler, engines, symbol, decl)?;
-
-        self.resolve_associated_type_from_type_id(
-            handler,
-            engines,
-            module,
-            symbol,
-            engines
-                .te()
-                .insert(engines, type_info, symbol.span().source_id()),
-            as_trait,
-            self_type,
-        )
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn resolve_associated_item(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        module: &Module,
-        symbol: &Ident,
-        decl: ResolvedDeclaration,
-        as_trait: Option<CallPath>,
-        self_type: Option<TypeId>,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        let type_info = self.decl_to_type_info(handler, engines, symbol, decl)?;
-
-        self.resolve_associated_item_from_type_id(
-            handler,
-            engines,
-            module,
-            symbol,
-            engines
-                .te()
-                .insert(engines, type_info, symbol.span().source_id()),
-            as_trait,
-            self_type,
-        )
-    }
-
-    fn decl_to_type_info(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        symbol: &Ident,
-        decl: ResolvedDeclaration,
-    ) -> Result<TypeInfo, ErrorEmitted> {
-        match decl {
-            ResolvedDeclaration::Parsed(_decl) => todo!(),
-            ResolvedDeclaration::Typed(decl) => Ok(match decl.clone() {
-                ty::TyDecl::StructDecl(struct_ty_decl) => {
-                    let struct_decl = engines.de().get_struct(&struct_ty_decl.decl_id);
-                    TypeInfo::Struct(DeclRef::new(
-                        struct_decl.name().clone(),
-                        struct_ty_decl.decl_id,
-                        struct_decl.span().clone(),
-                    ))
-                }
-                ty::TyDecl::EnumDecl(enum_ty_decl) => {
-                    let enum_decl = engines.de().get_enum(&enum_ty_decl.decl_id);
-                    TypeInfo::Enum(DeclRef::new(
-                        enum_decl.name().clone(),
-                        enum_ty_decl.decl_id,
-                        enum_decl.span().clone(),
-                    ))
-                }
-                ty::TyDecl::TraitTypeDecl(type_decl) => {
-                    let type_decl = engines.de().get_type(&type_decl.decl_id);
-                    (*engines.te().get(type_decl.ty.clone().unwrap().type_id)).clone()
-                }
-                _ => {
-                    return Err(handler.emit_err(CompileError::SymbolNotFound {
-                        name: symbol.clone(),
-                        span: symbol.span(),
-                    }))
-                }
-            }),
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn resolve_associated_type_from_type_id(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        module: &Module,
-        symbol: &Ident,
-        type_id: TypeId,
-        as_trait: Option<CallPath>,
-        self_type: Option<TypeId>,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        let item_decl = self.resolve_associated_item_from_type_id(
-            handler, engines, module, symbol, type_id, as_trait, self_type,
-        )?;
-        Ok(item_decl)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn resolve_associated_item_from_type_id(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        module: &Module,
-        symbol: &Ident,
-        type_id: TypeId,
-        as_trait: Option<CallPath>,
-        self_type: Option<TypeId>,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        let type_id = if engines.te().get(type_id).is_self_type() {
-            if let Some(self_type) = self_type {
-                self_type
-            } else {
-                return Err(handler.emit_err(CompileError::Internal(
-                    "Self type not provided.",
-                    symbol.span(),
-                )));
-            }
-        } else {
-            type_id
-        };
-        let item_ref = module
-            .current_items()
-            .implemented_traits
-            .get_trait_item_for_type(handler, engines, symbol, type_id, as_trait)?;
-        match item_ref {
-            ResolvedTraitImplItem::Parsed(_item) => todo!(),
-            ResolvedTraitImplItem::Typed(item) => match item {
-                TyTraitItem::Fn(fn_ref) => Ok(ResolvedDeclaration::Typed(fn_ref.into())),
-                TyTraitItem::Constant(const_ref) => {
-                    Ok(ResolvedDeclaration::Typed(const_ref.into()))
-                }
-                TyTraitItem::Type(type_ref) => Ok(ResolvedDeclaration::Typed(type_ref.into())),
-            },
-        }
-    }
-
-    fn resolve_symbol_helper(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        symbol: &Ident,
-        module: &Module,
-    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
-        // Check locally declared items. Any name clash with imports will have already been reported as an error.
-        if let Some(decl) = module.current_items().symbols.get(symbol) {
-            return Ok(decl.clone());
-        }
-        // Check locally declared items. Any name clash with imports will have already been reported as an error.
-        if let Some(decl) = module.current_items().symbols.get(symbol) {
-            return Ok(decl.clone());
-        }
-        // Check item imports
-        if let Some((_, _, decl)) = module.current_items().use_item_synonyms.get(symbol) {
-            return Ok(decl.clone());
-        }
-        // Check glob imports
-        if let Some(decls) = module.current_items().use_glob_synonyms.get(symbol) {
-            if decls.len() == 1 {
-                return Ok(decls[0].1.clone());
-            } else if decls.is_empty() {
-                return Err(handler.emit_err(CompileError::Internal(
-                    "The name {symbol} was bound in a star import, but no corresponding module paths were found",
-                    symbol.span(),
-                )));
-            } else {
-                // Symbol not found
-                return Err(handler.emit_err(CompileError::SymbolWithMultipleBindings {
-                    name: symbol.clone(),
-                    paths: decls
-                        .iter()
-                        .map(|(path, decl)| {
-                            let mut path_strs =
-                                path.iter().map(|x| x.to_string()).collect::<Vec<_>>();
-                            // Add the enum name to the path if the decl is an enum variant.
-                            match decl {
-                                ResolvedDeclaration::Parsed(decl) => {
-                                    if let Declaration::EnumVariantDeclaration(decl) = decl {
-                                        let enum_ref = engines.pe().get_enum(&decl.enum_ref);
-                                        path_strs.push(enum_ref.name().to_string())
-                                    };
-                                }
-                                ResolvedDeclaration::Typed(decl) => {
-                                    if let TyDecl::EnumVariantDecl(ty::EnumVariantDecl {
-                                        enum_ref,
-                                        ..
-                                    }) = decl
-                                    {
-                                        path_strs.push(enum_ref.name().to_string())
-                                    };
-                                }
-                            }
-                            path_strs.join("::")
-                        })
-                        .collect(),
-                    span: symbol.span(),
-                }));
-            }
-        }
-        // Symbol not found
-        Err(handler.emit_err(CompileError::SymbolNotFound {
-            name: symbol.clone(),
-            span: symbol.span(),
-        }))
-    }
 }
 
 impl From<Module> for Root {
@@ -943,12 +824,6 @@ impl From<Module> for Root {
     }
 }
 
-impl From<Namespace> for Root {
-    fn from(namespace: Namespace) -> Self {
-        namespace.root
-    }
-}
-
 fn is_ancestor(src: &ModulePath, dst: &ModulePath) -> bool {
     dst.len() >= src.len() && src.iter().zip(dst).all(|(src, dst)| src == dst)
 }
diff --git a/sway-core/src/semantic_analysis/namespace/trait_map.rs b/sway-core/src/semantic_analysis/namespace/trait_map.rs
index 2cd7d0dd3d6..1fb39cf2982 100644
--- a/sway-core/src/semantic_analysis/namespace/trait_map.rs
+++ b/sway-core/src/semantic_analysis/namespace/trait_map.rs
@@ -6,26 +6,50 @@ use std::{
     sync::Arc,
 };
 
-use hashbrown::HashSet;
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
 };
-use sway_types::{BaseIdent, Ident, Span, Spanned};
+use sway_types::{integer_bits::IntegerBits, BaseIdent, Ident, Span, Spanned};
 
 use crate::{
-    decl_engine::{DeclEngineGet, DeclEngineInsert},
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineGet, DeclEngineGetParsedDeclId, DeclEngineInsert,
+    },
     engine_threading::*,
     language::{
-        parsed::ImplItem,
+        parsed::{EnumDeclaration, ImplItem, StructDeclaration},
         ty::{self, TyImplItem, TyTraitItem},
         CallPath,
     },
     type_system::{SubstTypes, TypeId},
-    IncludeSelf, TraitConstraint, TypeArgument, TypeEngine, TypeInfo, TypeSubstMap, UnifyCheck,
+    IncludeSelf, SubstTypesContext, TraitConstraint, TypeArgument, TypeEngine, TypeInfo,
+    TypeSubstMap, UnifyCheck,
 };
 
-use super::TryInsertingTraitImplOnFailure;
+/// Enum used to pass a value asking for insertion of type into trait map when an implementation
+/// of the trait cannot be found.
+#[derive(Debug)]
+pub enum TryInsertingTraitImplOnFailure {
+    Yes,
+    No,
+}
+
+#[derive(Clone)]
+pub enum CodeBlockFirstPass {
+    Yes,
+    No,
+}
+
+impl From<bool> for CodeBlockFirstPass {
+    fn from(value: bool) -> Self {
+        if value {
+            CodeBlockFirstPass::Yes
+        } else {
+            CodeBlockFirstPass::No
+        }
+    }
+}
 
 #[derive(Clone, Debug)]
 struct TraitSuffix {
@@ -125,8 +149,41 @@ struct TraitEntry {
     value: TraitValue,
 }
 
-/// Map of trait name and type to [TraitItems].
-type TraitImpls = Vec<TraitEntry>;
+/// Map of string of type entry id and vec of [TraitEntry].
+/// We are using the HashMap as a wrapper to the vec so the TraitMap algorithms
+/// don't need to traverse every TraitEntry.
+type TraitImpls = im::HashMap<TypeRootFilter, im::Vector<TraitEntry>>;
+
+#[derive(Clone, Hash, Eq, PartialEq, Debug)]
+enum TypeRootFilter {
+    Unknown,
+    Never,
+    Placeholder,
+    TypeParam(usize),
+    StringSlice,
+    StringArray(usize),
+    U8,
+    U16,
+    U32,
+    U64,
+    U256,
+    Bool,
+    Custom(String),
+    B256,
+    Contract,
+    ErrorRecovery,
+    Tuple(usize),
+    Enum(ParsedDeclId<EnumDeclaration>),
+    Struct(ParsedDeclId<StructDeclaration>),
+    ContractCaller(String),
+    Array(usize),
+    Storage,
+    RawUntypedPtr,
+    RawUntypedSlice,
+    Ptr,
+    Slice,
+    TraitType(String),
+}
 
 /// Map holding trait implementations for types.
 ///
@@ -135,7 +192,7 @@ type TraitImpls = Vec<TraitEntry>;
 #[derive(Clone, Debug, Default)]
 pub(crate) struct TraitMap {
     trait_impls: TraitImpls,
-    satisfied_cache: hashbrown::HashSet<u64>,
+    satisfied_cache: im::HashSet<u64>,
 }
 
 pub(crate) enum IsImplSelf {
@@ -198,6 +255,8 @@ impl TraitMap {
                 }
             }
 
+            let trait_impls = self.get_impls_mut(engines, type_id);
+
             // check to see if adding this trait will produce a conflicting definition
             for TraitEntry {
                 key:
@@ -211,7 +270,7 @@ impl TraitMap {
                         trait_items: map_trait_items,
                         impl_span: existing_impl_span,
                     },
-            } in self.trait_impls.iter()
+            } in trait_impls.iter()
             {
                 let CallPath {
                     suffix:
@@ -412,10 +471,16 @@ impl TraitMap {
             impl_span,
         };
         let entry = TraitEntry { key, value };
-        let trait_impls: TraitImpls = vec![entry];
+        let mut trait_impls: TraitImpls =
+            im::HashMap::<TypeRootFilter, im::Vector<TraitEntry>>::new();
+        let type_root_filter = Self::get_type_root_filter(engines, type_id);
+        let mut impls_vector = im::Vector::<TraitEntry>::new();
+        impls_vector.push_back(entry);
+        trait_impls.insert(type_root_filter, impls_vector);
+
         let trait_map = TraitMap {
             trait_impls,
-            satisfied_cache: HashSet::default(),
+            satisfied_cache: im::HashSet::default(),
         };
 
         self.extend(trait_map, engines);
@@ -507,24 +572,42 @@ impl TraitMap {
     /// re-insert them under `type_id`. Moreover, the impl block for
     /// `Data<T, T>` needs to be able to call methods that are defined in the
     /// impl block of `Data<T, F>`
-    pub(crate) fn insert_for_type(&mut self, engines: &Engines, type_id: TypeId) {
-        self.extend(self.filter_by_type(type_id, engines), engines);
+    pub(crate) fn insert_for_type(
+        &mut self,
+        engines: &Engines,
+        type_id: TypeId,
+        code_block_first_pass: CodeBlockFirstPass,
+    ) {
+        self.extend(
+            self.filter_by_type(type_id, engines, code_block_first_pass),
+            engines,
+        );
     }
 
     /// Given [TraitMap]s `self` and `other`, extend `self` with `other`,
     /// extending existing entries when possible.
     pub(crate) fn extend(&mut self, other: TraitMap, engines: &Engines) {
-        for oe in other.trait_impls.into_iter() {
-            let pos = self
-                .trait_impls
-                .binary_search_by(|se| se.key.cmp(&oe.key, &OrdWithEnginesContext::new(engines)));
+        for (impls_key, oe_vec) in other.trait_impls.iter() {
+            let self_vec = if let Some(self_vec) = self.trait_impls.get_mut(impls_key) {
+                self_vec
+            } else {
+                self.trait_impls
+                    .insert(impls_key.clone(), im::Vector::<TraitEntry>::new());
+                self.trait_impls.get_mut(impls_key).unwrap()
+            };
 
-            match pos {
-                Ok(pos) => self.trait_impls[pos]
-                    .value
-                    .trait_items
-                    .extend(oe.value.trait_items),
-                Err(pos) => self.trait_impls.insert(pos, oe),
+            for oe in oe_vec.iter() {
+                let pos = self_vec.binary_search_by(|se| {
+                    se.key.cmp(&oe.key, &OrdWithEnginesContext::new(engines))
+                });
+
+                match pos {
+                    Ok(pos) => self_vec[pos]
+                        .value
+                        .trait_items
+                        .extend(oe.value.trait_items.clone()),
+                    Err(pos) => self_vec.insert(pos, oe.clone()),
+                }
             }
         }
     }
@@ -533,14 +616,26 @@ impl TraitMap {
     /// the entries from `self` that implement a trait from the declaration with that span.
     pub(crate) fn filter_by_trait_decl_span(&self, trait_decl_span: Span) -> TraitMap {
         let mut trait_map = TraitMap::default();
-        for entry in self.trait_impls.iter() {
-            if entry
-                .key
-                .trait_decl_span
-                .as_ref()
-                .map_or(false, |span| span == &trait_decl_span)
-            {
-                trait_map.trait_impls.push(entry.clone());
+        for (key, vec) in self.trait_impls.iter() {
+            for entry in vec {
+                if entry
+                    .key
+                    .trait_decl_span
+                    .as_ref()
+                    .map_or(false, |span| span == &trait_decl_span)
+                {
+                    let trait_map_vec =
+                        if let Some(trait_map_vec) = trait_map.trait_impls.get_mut(key) {
+                            trait_map_vec
+                        } else {
+                            trait_map
+                                .trait_impls
+                                .insert(key.clone(), im::Vector::<TraitEntry>::new());
+                            trait_map.trait_impls.get_mut(key).unwrap()
+                        };
+
+                    trait_map_vec.push_back(entry.clone());
+                }
             }
         }
         trait_map
@@ -653,7 +748,12 @@ impl TraitMap {
     /// have `Data<T, T>: get_first(self) -> T` and
     /// `Data<T, T>: get_second(self) -> T`, and we can create a new [TraitMap]
     /// with those entries for `Data<T, T>`.
-    pub(crate) fn filter_by_type(&self, type_id: TypeId, engines: &Engines) -> TraitMap {
+    pub(crate) fn filter_by_type(
+        &self,
+        type_id: TypeId,
+        engines: &Engines,
+        code_block_first_pass: CodeBlockFirstPass,
+    ) -> TraitMap {
         let unify_checker = UnifyCheck::constraint_subset(engines);
 
         // a curried version of the decider protocol to use in the helper functions
@@ -661,7 +761,7 @@ impl TraitMap {
         let mut all_types = type_id.extract_inner_types(engines, IncludeSelf::No);
         all_types.insert(type_id);
         let all_types = all_types.into_iter().collect::<Vec<_>>();
-        self.filter_by_type_inner(engines, all_types, decider)
+        self.filter_by_type_inner(engines, all_types, decider, code_block_first_pass)
     }
 
     /// Filters the entries in `self` with the given [TypeId] `type_id` and
@@ -726,6 +826,7 @@ impl TraitMap {
         &self,
         type_id: TypeId,
         engines: &Engines,
+        code_block_first_pass: CodeBlockFirstPass,
     ) -> TraitMap {
         let unify_checker = UnifyCheck::constraint_subset(engines);
         let unify_checker_for_item_import = UnifyCheck::non_generic_constraint_subset(engines);
@@ -734,7 +835,12 @@ impl TraitMap {
         let decider = |left: TypeId, right: TypeId| {
             unify_checker.check(left, right) || unify_checker_for_item_import.check(right, left)
         };
-        let mut trait_map = self.filter_by_type_inner(engines, vec![type_id], decider);
+        let mut trait_map = self.filter_by_type_inner(
+            engines,
+            vec![type_id],
+            decider,
+            code_block_first_pass.clone(),
+        );
         let all_types = type_id
             .extract_inner_types(engines, IncludeSelf::No)
             .into_iter()
@@ -743,7 +849,7 @@ impl TraitMap {
         let decider2 = |left: TypeId, right: TypeId| unify_checker.check(left, right);
 
         trait_map.extend(
-            self.filter_by_type_inner(engines, all_types, decider2),
+            self.filter_by_type_inner(engines, all_types, decider2, code_block_first_pass),
             engines,
         );
         trait_map
@@ -754,27 +860,29 @@ impl TraitMap {
         engines: &Engines,
         mut all_types: Vec<TypeId>,
         decider: impl Fn(TypeId, TypeId) -> bool,
+        code_block_first_pass: CodeBlockFirstPass,
     ) -> TraitMap {
         let type_engine = engines.te();
         let decl_engine = engines.de();
         let mut trait_map = TraitMap::default();
-        for TraitEntry {
-            key:
-                TraitKey {
-                    name: map_trait_name,
-                    type_id: map_type_id,
-                    trait_decl_span: map_trait_decl_span,
-                },
-            value:
-                TraitValue {
-                    trait_items: map_trait_items,
-                    impl_span,
-                },
-        } in self.trait_impls.iter()
-        {
-            for type_id in all_types.iter_mut() {
-                let type_info = type_engine.get(*type_id);
-                if !type_info.can_change(decl_engine) && *type_id == *map_type_id {
+        for type_id in all_types.iter_mut() {
+            let type_info = type_engine.get(*type_id);
+            let impls = self.get_impls(engines, *type_id);
+            for TraitEntry {
+                key:
+                    TraitKey {
+                        name: map_trait_name,
+                        type_id: map_type_id,
+                        trait_decl_span: map_trait_decl_span,
+                    },
+                value:
+                    TraitValue {
+                        trait_items: map_trait_items,
+                        impl_span,
+                    },
+            } in impls.iter()
+            {
+                if !type_info.can_change(engines) && *type_id == *map_type_id {
                     trait_map.insert_inner(
                         map_trait_name.clone(),
                         impl_span.clone(),
@@ -802,7 +910,11 @@ impl TraitMap {
                         *map_type_id,
                         *type_id,
                     );
-                    type_id.subst(&type_mapping, engines);
+                    type_id.subst(&SubstTypesContext::new(
+                        engines,
+                        &type_mapping,
+                        matches!(code_block_first_pass, CodeBlockFirstPass::No),
+                    ));
                     let trait_items: TraitItems = map_trait_items
                         .clone()
                         .into_iter()
@@ -814,9 +926,18 @@ impl TraitMap {
                                     if decl.is_trait_method_dummy && !insertable {
                                         None
                                     } else {
-                                        decl.subst(&type_mapping, engines);
+                                        decl.subst(&SubstTypesContext::new(
+                                            engines,
+                                            &type_mapping,
+                                            matches!(code_block_first_pass, CodeBlockFirstPass::No),
+                                        ));
                                         let new_ref = decl_engine
-                                            .insert(decl)
+                                            .insert(
+                                                decl,
+                                                decl_engine
+                                                    .get_parsed_decl_id(decl_ref.id())
+                                                    .as_ref(),
+                                            )
                                             .with_parent(decl_engine, decl_ref.id().into());
                                         Some((
                                             name,
@@ -826,8 +947,15 @@ impl TraitMap {
                                 }
                                 ty::TyTraitItem::Constant(decl_ref) => {
                                     let mut decl = (*decl_engine.get(decl_ref.id())).clone();
-                                    decl.subst(&type_mapping, engines);
-                                    let new_ref = decl_engine.insert(decl);
+                                    decl.subst(&SubstTypesContext::new(
+                                        engines,
+                                        &type_mapping,
+                                        matches!(code_block_first_pass, CodeBlockFirstPass::No),
+                                    ));
+                                    let new_ref = decl_engine.insert(
+                                        decl,
+                                        decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                                    );
                                     Some((
                                         name,
                                         ResolvedTraitImplItem::Typed(TyImplItem::Constant(new_ref)),
@@ -835,8 +963,15 @@ impl TraitMap {
                                 }
                                 ty::TyTraitItem::Type(decl_ref) => {
                                     let mut decl = (*decl_engine.get(decl_ref.id())).clone();
-                                    decl.subst(&type_mapping, engines);
-                                    let new_ref = decl_engine.insert(decl);
+                                    decl.subst(&SubstTypesContext::new(
+                                        engines,
+                                        &type_mapping,
+                                        matches!(code_block_first_pass, CodeBlockFirstPass::No),
+                                    ));
+                                    let new_ref = decl_engine.insert(
+                                        decl,
+                                        decl_engine.get_parsed_decl_id(decl_ref.id()).as_ref(),
+                                    );
                                     Some((
                                         name,
                                         ResolvedTraitImplItem::Typed(TyImplItem::Type(new_ref)),
@@ -892,7 +1027,8 @@ impl TraitMap {
         if matches!(&*type_engine.get(type_id), TypeInfo::ErrorRecovery(_)) {
             return items;
         }
-        for entry in self.trait_impls.iter() {
+        let impls = self.get_impls(engines, type_id);
+        for entry in impls.iter() {
             if unify_check.check(type_id, entry.key.type_id) {
                 let mut trait_items = entry
                     .value
@@ -925,11 +1061,13 @@ impl TraitMap {
         if matches!(&*type_engine.get(*type_id), TypeInfo::ErrorRecovery(_)) {
             return spans;
         }
-        for entry in self.trait_impls.iter() {
+        let impls = self.get_impls(engines, *type_id);
+        for entry in impls.iter() {
             if unify_check.check(*type_id, entry.key.type_id) {
                 spans.push(entry.value.impl_span.clone());
             }
         }
+
         spans
     }
 
@@ -938,18 +1076,25 @@ impl TraitMap {
     pub(crate) fn get_impl_spans_for_trait_name(&self, trait_name: &CallPath) -> Vec<Span> {
         self.trait_impls
             .iter()
-            .filter_map(|entry| {
-                let map_trait_name = CallPath {
-                    prefixes: entry.key.name.prefixes.clone(),
-                    suffix: entry.key.name.suffix.name.clone(),
-                    is_absolute: entry.key.name.is_absolute,
-                };
-                if &map_trait_name == trait_name {
-                    return Some(entry.value.impl_span.clone());
-                }
-                None
+            .map(|(_, impls)| {
+                impls
+                    .iter()
+                    .filter_map(|entry| {
+                        let map_trait_name = CallPath {
+                            prefixes: entry.key.name.prefixes.clone(),
+                            suffix: entry.key.name.suffix.name.clone(),
+                            is_absolute: entry.key.name.is_absolute,
+                        };
+                        if &map_trait_name == trait_name {
+                            Some(entry.value.impl_span.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<Span>>()
             })
-            .collect()
+            .collect::<Vec<Vec<Span>>>()
+            .concat()
     }
 
     /// Find the entries in `self` that are equivalent to `type_id` with trait
@@ -976,7 +1121,8 @@ impl TraitMap {
         if matches!(&*type_engine.get(type_id), TypeInfo::ErrorRecovery(_)) {
             return items;
         }
-        for e in self.trait_impls.iter() {
+        let impls = self.get_impls(engines, type_id);
+        for e in impls.iter() {
             let map_trait_name = CallPath {
                 prefixes: e.key.name.prefixes.clone(),
                 suffix: e.key.name.suffix.name.clone(),
@@ -1037,7 +1183,8 @@ impl TraitMap {
         if matches!(&*type_engine.get(type_id), TypeInfo::ErrorRecovery(_)) {
             return trait_names;
         }
-        for entry in self.trait_impls.iter() {
+        let impls = self.get_impls(engines, type_id);
+        for entry in impls.iter() {
             if unify_check.check(type_id, entry.key.type_id) {
                 let trait_call_path = CallPath {
                     prefixes: entry.key.name.prefixes.clone(),
@@ -1175,6 +1322,7 @@ impl TraitMap {
     }
 
     /// Checks to see if the trait constraints are satisfied for a given type.
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn check_if_trait_constraints_are_satisfied_for_type(
         &mut self,
         handler: &Handler,
@@ -1183,6 +1331,7 @@ impl TraitMap {
         access_span: &Span,
         engines: &Engines,
         try_inserting_trait_impl_on_failure: TryInsertingTraitImplOnFailure,
+        code_block_first_pass: CodeBlockFirstPass,
     ) -> Result<(), ErrorEmitted> {
         let type_engine = engines.te();
 
@@ -1213,6 +1362,7 @@ impl TraitMap {
             access_span,
             engines,
             try_inserting_trait_impl_on_failure,
+            code_block_first_pass,
         ) {
             Ok(()) => {
                 self.satisfied_cache.insert(hash);
@@ -1222,6 +1372,7 @@ impl TraitMap {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn check_if_trait_constraints_are_satisfied_for_type_inner(
         &mut self,
         handler: &Handler,
@@ -1230,42 +1381,15 @@ impl TraitMap {
         access_span: &Span,
         engines: &Engines,
         try_inserting_trait_impl_on_failure: TryInsertingTraitImplOnFailure,
+        code_block_first_pass: CodeBlockFirstPass,
     ) -> Result<(), ErrorEmitted> {
         let type_engine = engines.te();
 
-        // If the type is generic/placeholder, its definition needs to contains all
-        // constraints
-        match &*type_engine.get(type_id) {
-            TypeInfo::UnknownGeneric {
-                trait_constraints, ..
-            } => {
-                let all = constraints.iter().all(|required| {
-                    trait_constraints.iter().any(|constraint| {
-                        constraint.eq(required, &PartialEqWithEnginesContext::new(engines))
-                    })
-                });
-                if all {
-                    return Ok(());
-                }
-            }
-            TypeInfo::Placeholder(p) => {
-                let all = constraints.iter().all(|required| {
-                    p.trait_constraints.iter().any(|constraint| {
-                        constraint.eq(required, &PartialEqWithEnginesContext::new(engines))
-                    })
-                });
-                if all {
-                    return Ok(());
-                }
-            }
-            _ => {}
-        }
-
         let _decl_engine = engines.de();
         let unify_check = UnifyCheck::non_dynamic_equality(engines);
 
-        let all_impld_traits: BTreeSet<(Ident, TypeId)> = self
-            .trait_impls
+        let impls = self.get_impls(engines, type_id);
+        let all_impld_traits: BTreeSet<(Ident, TypeId)> = impls
             .iter()
             .filter_map(|e| {
                 let key = &e.key;
@@ -1333,7 +1457,7 @@ impl TraitMap {
                     try_inserting_trait_impl_on_failure,
                     TryInsertingTraitImplOnFailure::Yes
                 ) {
-                    self.insert_for_type(engines, type_id);
+                    self.insert_for_type(engines, type_id, code_block_first_pass.clone());
                     return self.check_if_trait_constraints_are_satisfied_for_type(
                         handler,
                         type_id,
@@ -1341,6 +1465,7 @@ impl TraitMap {
                         access_span,
                         engines,
                         TryInsertingTraitImplOnFailure::No,
+                        code_block_first_pass.clone(),
                     );
                 } else {
                     let mut type_arguments_string = "".to_string();
@@ -1366,4 +1491,130 @@ impl TraitMap {
             Ok(())
         })
     }
+
+    pub fn get_trait_constraints_are_satisfied_for_types(
+        &self,
+        _handler: &Handler,
+        type_id: TypeId,
+        constraints: &[TraitConstraint],
+        engines: &Engines,
+    ) -> Result<Vec<(TypeId, String)>, ErrorEmitted> {
+        let _decl_engine = engines.de();
+        let unify_check = UnifyCheck::coercion(engines);
+        let unify_check_equality = UnifyCheck::non_dynamic_equality(engines);
+
+        let impls = self.get_impls(engines, type_id);
+        let impld_traits_type_ids: Vec<(TypeId, String)> = impls
+            .iter()
+            .filter_map(|e| {
+                let key = &e.key;
+                let mut res = None;
+                for constraint in constraints {
+                    if key.name.suffix.name == constraint.trait_name.suffix
+                        && key
+                            .name
+                            .suffix
+                            .args
+                            .iter()
+                            .zip(constraint.type_arguments.iter())
+                            .all(|(a1, a2)| unify_check_equality.check(a1.type_id, a2.type_id))
+                        && unify_check.check(type_id, key.type_id)
+                    {
+                        let name_type_args = if !key.name.suffix.args.is_empty() {
+                            format!("<{}>", engines.help_out(key.name.suffix.args.clone()))
+                        } else {
+                            "".to_string()
+                        };
+                        let name = format!("{}{}", key.name.suffix.name.as_str(), name_type_args);
+                        res = Some((key.type_id, name));
+                        break;
+                    }
+                }
+                res
+            })
+            .collect();
+
+        Ok(impld_traits_type_ids)
+    }
+
+    fn get_impls_mut(&mut self, engines: &Engines, type_id: TypeId) -> &mut im::Vector<TraitEntry> {
+        let type_root_filter = Self::get_type_root_filter(engines, type_id);
+        if !self.trait_impls.contains_key(&type_root_filter) {
+            self.trait_impls
+                .insert(type_root_filter.clone(), im::Vector::new());
+        }
+
+        self.trait_impls.get_mut(&type_root_filter).unwrap()
+    }
+
+    fn get_impls(&self, engines: &Engines, type_id: TypeId) -> im::Vector<TraitEntry> {
+        let type_root_filter = Self::get_type_root_filter(engines, type_id);
+        let mut vec = self
+            .trait_impls
+            .get(&type_root_filter)
+            .cloned()
+            .unwrap_or_default();
+        if type_root_filter != TypeRootFilter::Placeholder {
+            vec.extend(
+                self.trait_impls
+                    .get(&TypeRootFilter::Placeholder)
+                    .cloned()
+                    .unwrap_or_default(),
+            );
+        }
+        vec
+    }
+
+    // Return a string representing only the base type.
+    // This is used by the trait map to filter the entries into a HashMap with the return type string as key.
+    fn get_type_root_filter(engines: &Engines, type_id: TypeId) -> TypeRootFilter {
+        use TypeInfo::*;
+        match &*engines.te().get(type_id) {
+            Unknown => TypeRootFilter::Unknown,
+            Never => TypeRootFilter::Never,
+            UnknownGeneric { .. } | Placeholder(_) => TypeRootFilter::Placeholder,
+            TypeParam(n) => TypeRootFilter::TypeParam(*n),
+            StringSlice => TypeRootFilter::StringSlice,
+            StringArray(x) => TypeRootFilter::StringArray(x.val()),
+            UnsignedInteger(x) => match x {
+                IntegerBits::Eight => TypeRootFilter::U8,
+                IntegerBits::Sixteen => TypeRootFilter::U16,
+                IntegerBits::ThirtyTwo => TypeRootFilter::U32,
+                IntegerBits::SixtyFour => TypeRootFilter::U64,
+                IntegerBits::V256 => TypeRootFilter::U256,
+            },
+            Boolean => TypeRootFilter::Bool,
+            Custom {
+                qualified_call_path: call_path,
+                ..
+            } => TypeRootFilter::Custom(call_path.call_path.suffix.to_string()),
+            B256 => TypeRootFilter::B256,
+            Numeric => TypeRootFilter::U64, // u64 is the default
+            Contract => TypeRootFilter::Contract,
+            ErrorRecovery(_) => TypeRootFilter::ErrorRecovery,
+            Tuple(fields) => TypeRootFilter::Tuple(fields.len()),
+            UntypedEnum(decl_id) => TypeRootFilter::Enum(*decl_id),
+            UntypedStruct(decl_id) => TypeRootFilter::Struct(*decl_id),
+            Enum(decl_id) => {
+                // TODO Remove unwrap once #6475 is fixed
+                TypeRootFilter::Enum(engines.de().get_parsed_decl_id(decl_id).unwrap())
+            }
+            Struct(decl_id) => {
+                // TODO Remove unwrap once #6475 is fixed
+                TypeRootFilter::Struct(engines.de().get_parsed_decl_id(decl_id).unwrap())
+            }
+            ContractCaller { abi_name, .. } => TypeRootFilter::ContractCaller(abi_name.to_string()),
+            Array(_, length) => TypeRootFilter::Array(length.val()),
+            Storage { .. } => TypeRootFilter::Storage,
+            RawUntypedPtr => TypeRootFilter::RawUntypedPtr,
+            RawUntypedSlice => TypeRootFilter::RawUntypedSlice,
+            Ptr(_) => TypeRootFilter::Ptr,
+            Slice(_) => TypeRootFilter::Slice,
+            Alias { ty, .. } => Self::get_type_root_filter(engines, ty.type_id),
+            TraitType { name, .. } => TypeRootFilter::TraitType(name.to_string()),
+            Ref {
+                referenced_type, ..
+            } => Self::get_type_root_filter(engines, referenced_type.type_id),
+        }
+    }
 }
diff --git a/sway-core/src/semantic_analysis/node_dependencies.rs b/sway-core/src/semantic_analysis/node_dependencies.rs
index f9d67914263..c34feeab4e6 100644
--- a/sway-core/src/semantic_analysis/node_dependencies.rs
+++ b/sway-core/src/semantic_analysis/node_dependencies.rs
@@ -42,7 +42,7 @@ pub(crate) fn order_ast_nodes_by_dependency(
         Ok(())
     })?;
 
-    // Reorder the parsed AstNodes based on dependency.  Includes first, then uses, then
+    // Reorder the parsed AstNodes based on dependency. Includes first, then uses, then
     // reordered declarations, then anything else.  To keep the list stable and simple we can
     // use a basic insertion sort.
     Ok(nodes
@@ -315,6 +315,10 @@ impl Dependencies {
                 let decl = engines.pe().get_trait_type(decl_id);
                 self.gather_from_type_decl(engines, &decl)
             }
+            Declaration::TraitFnDeclaration(decl_id) => {
+                let decl = engines.pe().get_trait_fn(decl_id);
+                self.gather_from_trait_fn_decl(engines, &decl)
+            }
             Declaration::FunctionDeclaration(decl_id) => {
                 let fn_decl = engines.pe().get_function(decl_id);
                 self.gather_from_fn_decl(engines, &fn_decl)
@@ -376,14 +380,14 @@ impl Dependencies {
                     },
                 )
             }
-            Declaration::ImplTrait(decl_id) => {
-                let ImplTrait {
+            Declaration::ImplSelfOrTrait(decl_id) => {
+                let ImplSelfOrTrait {
                     impl_type_parameters,
                     trait_name,
                     implementing_for,
                     items,
                     ..
-                } = &*engines.pe().get_impl_trait(decl_id);
+                } = &*engines.pe().get_impl_self_or_trait(decl_id);
                 self.gather_from_call_path(trait_name, false, false)
                     .gather_from_type_argument(engines, implementing_for)
                     .gather_from_type_parameters(impl_type_parameters)
@@ -402,28 +406,6 @@ impl Dependencies {
                         }
                     })
             }
-            Declaration::ImplSelf(decl_id) => {
-                let ImplSelf {
-                    implementing_for,
-                    items,
-                    ..
-                } = &*engines.pe().get_impl_self(decl_id);
-                self.gather_from_type_argument(engines, implementing_for)
-                    .gather_from_iter(items.iter(), |deps, item| match item {
-                        ImplItem::Fn(fn_decl_id) => {
-                            let fn_decl = engines.pe().get_function(fn_decl_id);
-                            deps.gather_from_fn_decl(engines, &fn_decl)
-                        }
-                        ImplItem::Constant(decl_id) => {
-                            let const_decl = engines.pe().get_constant(decl_id);
-                            deps.gather_from_constant_decl(engines, &const_decl)
-                        }
-                        ImplItem::Type(decl_id) => {
-                            let type_decl = engines.pe().get_trait_type(decl_id);
-                            deps.gather_from_type_decl(engines, &type_decl)
-                        }
-                    })
-            }
             Declaration::AbiDeclaration(decl_id) => {
                 let AbiDeclaration {
                     interface_surface,
@@ -527,6 +509,18 @@ impl Dependencies {
         }
     }
 
+    fn gather_from_trait_fn_decl(self, engines: &Engines, fn_decl: &TraitFn) -> Self {
+        let TraitFn {
+            parameters,
+            return_type,
+            ..
+        } = fn_decl;
+        self.gather_from_iter(parameters.iter(), |deps, param| {
+            deps.gather_from_type_argument(engines, &param.type_argument)
+        })
+        .gather_from_type_argument(engines, return_type)
+    }
+
     fn gather_from_fn_decl(self, engines: &Engines, fn_decl: &FunctionDeclaration) -> Self {
         let FunctionDeclaration {
             parameters,
@@ -556,6 +550,7 @@ impl Dependencies {
             ExpressionKind::FunctionApplication(function_application_expression) => {
                 let FunctionApplicationExpression {
                     call_path_binding,
+                    resolved_call_path_binding: _,
                     arguments,
                 } = &**function_application_expression;
                 self.gather_from_call_path(&call_path_binding.inner, false, true)
@@ -597,6 +592,7 @@ impl Dependencies {
             ExpressionKind::Struct(struct_expression) => {
                 let StructExpression {
                     call_path_binding,
+                    resolved_call_path_binding: _,
                     fields,
                 } = &**struct_expression;
                 self.gather_from_call_path(&call_path_binding.inner, false, false)
@@ -816,6 +812,7 @@ impl Dependencies {
                 deps.gather_from_type_argument(engines, elem)
             }),
             TypeInfo::Array(elem_type, _) => self.gather_from_type_argument(engines, elem_type),
+            TypeInfo::Slice(elem_type) => self.gather_from_type_argument(engines, elem_type),
             TypeInfo::Struct(decl_ref) => self.gather_from_iter(
                 decl_engine.get_struct(decl_ref).fields.iter(),
                 |deps, field| deps.gather_from_type_argument(engines, &field.type_argument),
@@ -916,6 +913,10 @@ fn decl_name(engines: &Engines, decl: &Declaration) -> Option<DependentSymbol> {
             let decl = engines.pe().get_trait_type(decl_id);
             dep_sym(decl.name.clone())
         }
+        Declaration::TraitFnDeclaration(decl_id) => {
+            let decl = engines.pe().get_trait_fn(decl_id);
+            dep_sym(decl.name.clone())
+        }
         Declaration::StructDeclaration(decl_id) => {
             let decl = engines.pe().get_struct(decl_id);
             dep_sym(decl.name.clone())
@@ -937,37 +938,34 @@ fn decl_name(engines: &Engines, decl: &Declaration) -> Option<DependentSymbol> {
             let decl = engines.pe().get_type_alias(decl_id);
             dep_sym(decl.name.clone())
         }
-
-        // These have the added complexity of converting CallPath and/or TypeInfo into a name.
-        Declaration::ImplSelf(decl_id) => {
-            let decl = engines.pe().get_impl_self(decl_id);
-            let trait_name = Ident::new_with_override("self".into(), decl.implementing_for.span());
-            impl_sym(
-                trait_name,
-                &type_engine.get(decl.implementing_for.type_id),
-                decl.items
-                    .iter()
-                    .map(|item| match item {
-                        ImplItem::Fn(fn_decl_id) => {
-                            let fn_decl = engines.pe().get_function(fn_decl_id);
-                            fn_decl.name.to_string()
-                        }
-                        ImplItem::Constant(decl_id) => {
-                            let const_decl = engines.pe().get_constant(decl_id);
-                            const_decl.name.to_string()
-                        }
-                        ImplItem::Type(decl_id) => {
-                            let type_decl = engines.pe().get_trait_type(decl_id);
-                            type_decl.name.to_string()
-                        }
-                    })
-                    .collect::<Vec<String>>()
-                    .join(""),
-            )
-        }
-        Declaration::ImplTrait(decl_id) => {
-            let decl = engines.pe().get_impl_trait(decl_id);
-            if decl.trait_name.prefixes.is_empty() {
+        Declaration::ImplSelfOrTrait(decl_id) => {
+            let decl = engines.pe().get_impl_self_or_trait(decl_id);
+            if decl.is_self {
+                let trait_name =
+                    Ident::new_with_override("self".into(), decl.implementing_for.span());
+                impl_sym(
+                    trait_name,
+                    &type_engine.get(decl.implementing_for.type_id),
+                    decl.items
+                        .iter()
+                        .map(|item| match item {
+                            ImplItem::Fn(fn_decl_id) => {
+                                let fn_decl = engines.pe().get_function(fn_decl_id);
+                                fn_decl.name.to_string()
+                            }
+                            ImplItem::Constant(decl_id) => {
+                                let const_decl = engines.pe().get_constant(decl_id);
+                                const_decl.name.to_string()
+                            }
+                            ImplItem::Type(decl_id) => {
+                                let type_decl = engines.pe().get_trait_type(decl_id);
+                                type_decl.name.to_string()
+                            }
+                        })
+                        .collect::<Vec<String>>()
+                        .join(","),
+                )
+            } else if decl.trait_name.prefixes.is_empty() {
                 impl_sym(
                     decl.trait_name.suffix.clone(),
                     &type_engine.get(decl.implementing_for.type_id),
@@ -988,7 +986,7 @@ fn decl_name(engines: &Engines, decl: &Declaration) -> Option<DependentSymbol> {
                             }
                         })
                         .collect::<Vec<_>>()
-                        .join(""),
+                        .join(","),
                 )
             } else {
                 None
@@ -1033,6 +1031,8 @@ fn type_info_name(type_info: &TypeInfo) -> String {
         TypeInfo::ContractCaller { abi_name, .. } => {
             return format!("contract caller {abi_name}");
         }
+        TypeInfo::UntypedEnum(_) => "untyped enum",
+        TypeInfo::UntypedStruct(_) => "untyped struct",
         TypeInfo::Struct { .. } => "struct",
         TypeInfo::Enum { .. } => "enum",
         TypeInfo::Array(..) => "array",
diff --git a/sway-core/src/semantic_analysis/program.rs b/sway-core/src/semantic_analysis/program.rs
index 71f73f359d7..581a630d9b6 100644
--- a/sway-core/src/semantic_analysis/program.rs
+++ b/sway-core/src/semantic_analysis/program.rs
@@ -14,12 +14,12 @@ use sway_error::handler::{ErrorEmitted, Handler};
 use sway_ir::{Context, Module};
 
 use super::{
-    collection_context::SymbolCollectionContext, TypeCheckAnalysis, TypeCheckAnalysisContext,
-    TypeCheckFinalization, TypeCheckFinalizationContext,
+    symbol_collection_context::SymbolCollectionContext, TypeCheckAnalysis,
+    TypeCheckAnalysisContext, TypeCheckFinalization, TypeCheckFinalizationContext,
 };
 
 impl TyProgram {
-    /// Collects the given parsed program to produce a symbol map and module evaluation order.
+    /// Collects the given parsed program to produce a symbol maps.
     ///
     /// The given `initial_namespace` acts as an initial state for each module within this program.
     /// It should contain a submodule for each library package dependency.
@@ -44,6 +44,7 @@ impl TyProgram {
         handler: &Handler,
         engines: &Engines,
         parsed: &ParseProgram,
+        collection_ctx: &mut SymbolCollectionContext,
         mut namespace: namespace::Namespace,
         package_name: &str,
         build_config: Option<&BuildConfig>,
@@ -55,12 +56,20 @@ impl TyProgram {
                     new_encoding: false,
                 });
 
-        let mut ctx = TypeCheckContext::from_root(&mut namespace, engines, experimental)
-            .with_kind(parsed.kind);
+        let mut ctx =
+            TypeCheckContext::from_root(&mut namespace, collection_ctx, engines, experimental)
+                .with_kind(parsed.kind);
 
         let ParseProgram { root, kind } = parsed;
 
-        let root = ty::TyModule::type_check(handler, ctx.by_ref(), engines, parsed.kind, root)?;
+        let root = ty::TyModule::type_check(
+            handler,
+            ctx.by_ref(),
+            engines,
+            parsed.kind,
+            root,
+            build_config,
+        )?;
 
         let (kind, declarations, configurables) = Self::validate_root(
             handler,
@@ -73,7 +82,7 @@ impl TyProgram {
 
         let program = TyProgram {
             kind,
-            root,
+            root: (*root).clone(),
             declarations,
             configurables,
             storage_slots: vec![],
diff --git a/sway-core/src/semantic_analysis/collection_context.rs b/sway-core/src/semantic_analysis/symbol_collection_context.rs
similarity index 79%
rename from sway-core/src/semantic_analysis/collection_context.rs
rename to sway-core/src/semantic_analysis/symbol_collection_context.rs
index 9a59bf32072..2a3be6aa35d 100644
--- a/sway-core/src/semantic_analysis/collection_context.rs
+++ b/sway-core/src/semantic_analysis/symbol_collection_context.rs
@@ -1,5 +1,6 @@
 use crate::{
     language::{parsed::Declaration, Visibility},
+    namespace::LexicalScopeId,
     namespace::ModulePath,
     semantic_analysis::Namespace,
     Engines,
@@ -37,14 +38,37 @@ impl SymbolCollectionContext {
 
     /// Scope the `CollectionContext` with a new lexical scope.
     pub fn scoped<T>(
-        mut self,
+        &mut self,
         engines: &Engines,
-        with_scoped_ctx: impl FnOnce(SymbolCollectionContext) -> Result<T, ErrorEmitted>,
-    ) -> Result<T, ErrorEmitted> {
+        span: Span,
+        with_scoped_ctx: impl FnOnce(&mut SymbolCollectionContext) -> Result<T, ErrorEmitted>,
+    ) -> (Result<T, ErrorEmitted>, LexicalScopeId) {
+        let lexical_scope_id: LexicalScopeId = self
+            .namespace
+            .module_mut(engines)
+            .write(engines, |m| m.push_new_lexical_scope(span.clone()));
+        let ret = with_scoped_ctx(self);
         self.namespace
             .module_mut(engines)
-            .write(engines, |m| m.push_new_lexical_scope());
-        let ret = with_scoped_ctx(self.clone());
+            .write(engines, |m| m.pop_lexical_scope());
+        (ret, lexical_scope_id)
+    }
+
+    /// Enter the lexical scope corresponding to the given span and produce a
+    /// collection context ready for collecting its content.
+    ///
+    /// Returns the result of the given `with_ctx` function.
+    pub fn enter_lexical_scope<T>(
+        &mut self,
+        handler: &Handler,
+        engines: &Engines,
+        span: Span,
+        with_ctx: impl FnOnce(&mut SymbolCollectionContext) -> Result<T, ErrorEmitted>,
+    ) -> Result<T, ErrorEmitted> {
+        self.namespace.module_mut(engines).write(engines, |m| {
+            m.enter_lexical_scope(handler, engines, span.clone())
+        })?;
+        let ret = with_ctx(self);
         self.namespace
             .module_mut(engines)
             .write(engines, |m| m.pop_lexical_scope());
@@ -64,7 +88,7 @@ impl SymbolCollectionContext {
         with_submod_ctx: impl FnOnce(&mut SymbolCollectionContext) -> T,
     ) -> T {
         self.namespace
-            .push_new_submodule(engines, mod_name, visibility, module_span);
+            .push_submodule(engines, mod_name, visibility, module_span);
         //let Self { namespace, .. } = self;
         //let mut submod_ns = namespace.enter_submodule(mod_name, visibility, module_span);
         let ret = with_submod_ctx(self);
@@ -108,11 +132,12 @@ impl SymbolCollectionContext {
         handler: &Handler,
         engines: &Engines,
         src: &ModulePath,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .star_import(handler, engines, src, &mod_path)
+            .star_import(handler, engines, src, &mod_path, visibility)
     }
 
     /// Short-hand for performing a [Module::variant_star_import] with `mod_path` as the destination.
@@ -122,11 +147,12 @@ impl SymbolCollectionContext {
         engines: &Engines,
         src: &ModulePath,
         enum_name: &Ident,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .variant_star_import(handler, engines, src, &mod_path, enum_name)
+            .variant_star_import(handler, engines, src, &mod_path, enum_name, visibility)
     }
 
     /// Short-hand for performing a [Module::self_import] with `mod_path` as the destination.
@@ -136,11 +162,12 @@ impl SymbolCollectionContext {
         engines: &Engines,
         src: &ModulePath,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .self_import(handler, engines, src, &mod_path, alias)
+            .self_import(handler, engines, src, &mod_path, alias, visibility)
     }
 
     /// Short-hand for performing a [Module::item_import] with `mod_path` as the destination.
@@ -151,11 +178,12 @@ impl SymbolCollectionContext {
         src: &ModulePath,
         item: &Ident,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .item_import(handler, engines, src, item, &mod_path, alias)
+            .item_import(handler, engines, src, item, &mod_path, alias, visibility)
     }
 
     /// Short-hand for performing a [Module::variant_import] with `mod_path` as the destination.
@@ -168,6 +196,7 @@ impl SymbolCollectionContext {
         enum_name: &Ident,
         variant_name: &Ident,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut().root.variant_import(
@@ -178,6 +207,7 @@ impl SymbolCollectionContext {
             variant_name,
             &mod_path,
             alias,
+            visibility,
         )
     }
 }
diff --git a/sway-core/src/semantic_analysis/symbol_resolve.rs b/sway-core/src/semantic_analysis/symbol_resolve.rs
new file mode 100644
index 00000000000..60ac3da6a53
--- /dev/null
+++ b/sway-core/src/semantic_analysis/symbol_resolve.rs
@@ -0,0 +1,646 @@
+use sway_error::handler::Handler;
+
+use crate::{
+    ast_elements::binding::SymbolResolveTypeBinding,
+    decl_engine::{parsed_engine::ParsedDeclEngineReplace, parsed_id::ParsedDeclId},
+    language::{
+        parsed::{
+            AbiDeclaration, AstNode, AstNodeContent, CodeBlock, ConfigurableDeclaration,
+            ConstantDeclaration, Declaration, EnumDeclaration, EnumVariant, Expression,
+            ExpressionKind, FunctionDeclaration, FunctionParameter, ImplItem, ImplSelfOrTrait,
+            ParseModule, ParseProgram, ReassignmentTarget, Scrutinee, StorageDeclaration,
+            StorageEntry, StructDeclaration, StructExpressionField, StructField,
+            StructScrutineeField, Supertrait, TraitDeclaration, TraitFn, TraitItem,
+            TraitTypeDeclaration, TypeAliasDeclaration, VariableDeclaration,
+        },
+        CallPath, CallPathTree, ResolvedCallPath,
+    },
+    TraitConstraint, TypeArgument, TypeBinding, TypeParameter,
+};
+
+use super::symbol_resolve_context::SymbolResolveContext;
+
+pub trait ResolveSymbols {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext);
+}
+
+impl ResolveSymbols for ParseProgram {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        let ParseProgram { root, .. } = self;
+        root.resolve_symbols(handler, ctx.by_ref());
+    }
+}
+
+impl ResolveSymbols for ParseModule {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        let ParseModule {
+            submodules,
+            tree,
+            module_eval_order,
+            attributes: _,
+            span: _,
+            hash: _,
+            ..
+        } = self;
+
+        // Analyze submodules first in order of evaluation previously computed by the dependency graph.
+        module_eval_order.iter().for_each(|eval_mod_name| {
+            let (_name, submodule) = submodules
+                .iter_mut()
+                .find(|(submod_name, _submodule)| eval_mod_name == submod_name)
+                .unwrap();
+            submodule.module.resolve_symbols(handler, ctx.by_ref());
+        });
+
+        tree.root_nodes
+            .iter_mut()
+            .for_each(|node| node.resolve_symbols(handler, ctx.by_ref()))
+    }
+}
+
+impl ResolveSymbols for AstNode {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        match &mut self.content {
+            AstNodeContent::UseStatement(_) => {}
+            AstNodeContent::Declaration(decl) => decl.resolve_symbols(handler, ctx),
+            AstNodeContent::Expression(expr) => expr.resolve_symbols(handler, ctx),
+            AstNodeContent::IncludeStatement(_) => {}
+            AstNodeContent::Error(_, _) => {}
+        }
+    }
+}
+
+impl ResolveSymbols for Declaration {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        match self {
+            Declaration::VariableDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::FunctionDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::TraitDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::StructDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::EnumDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::EnumVariantDeclaration(_decl) => unreachable!(),
+            Declaration::ImplSelfOrTrait(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::AbiDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::ConstantDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::StorageDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::TypeAliasDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::TraitTypeDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::TraitFnDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            Declaration::ConfigurableDeclaration(decl_id) => decl_id.resolve_symbols(handler, ctx),
+        }
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<VariableDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut var_decl = pe.get_variable(self).as_ref().clone();
+        var_decl.body.resolve_symbols(handler, ctx);
+        pe.replace(*self, var_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<FunctionDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut fn_decl = pe.get_function(self).as_ref().clone();
+        fn_decl.body.resolve_symbols(handler, ctx);
+        pe.replace(*self, fn_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<TraitDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut trait_decl = ctx.engines().pe().get_trait(self).as_ref().clone();
+        trait_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, trait_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<StructDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut struct_decl = ctx.engines().pe().get_struct(self).as_ref().clone();
+        struct_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, struct_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<EnumDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut enum_decl = ctx.engines().pe().get_enum(self).as_ref().clone();
+        enum_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, enum_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<ConfigurableDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut configurable_decl = ctx.engines().pe().get_configurable(self).as_ref().clone();
+        configurable_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, configurable_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<ConstantDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut constant_decl = ctx.engines().pe().get_constant(self).as_ref().clone();
+        constant_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, constant_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<TraitTypeDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut trait_type_decl = ctx.engines().pe().get_trait_type(self).as_ref().clone();
+        trait_type_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, trait_type_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<TraitFn> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut trait_fn_decl = ctx.engines().pe().get_trait_fn(self).as_ref().clone();
+        trait_fn_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, trait_fn_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<ImplSelfOrTrait> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut impl_self_or_trait = ctx
+            .engines()
+            .pe()
+            .get_impl_self_or_trait(self)
+            .as_ref()
+            .clone();
+        impl_self_or_trait.resolve_symbols(handler, ctx);
+        pe.replace(*self, impl_self_or_trait);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<AbiDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut abi_decl = ctx.engines().pe().get_abi(self).as_ref().clone();
+        abi_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, abi_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<StorageDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut storage_decl = ctx.engines().pe().get_storage(self).as_ref().clone();
+        storage_decl.resolve_symbols(handler, ctx);
+        pe.replace(*self, storage_decl);
+    }
+}
+
+impl ResolveSymbols for ParsedDeclId<TypeAliasDeclaration> {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        let pe = ctx.engines().pe();
+        let mut type_alias = ctx.engines().pe().get_type_alias(self).as_ref().clone();
+        type_alias.resolve_symbols(handler, ctx);
+        pe.replace(*self, type_alias);
+    }
+}
+
+impl ResolveSymbols for ConfigurableDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.type_ascription.resolve_symbols(handler, ctx.by_ref());
+        if let Some(value) = self.value.as_mut() {
+            value.resolve_symbols(handler, ctx.by_ref())
+        }
+    }
+}
+
+impl ResolveSymbols for ConstantDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.type_ascription.resolve_symbols(handler, ctx.by_ref());
+        if let Some(value) = self.value.as_mut() {
+            value.resolve_symbols(handler, ctx.by_ref())
+        }
+    }
+}
+
+impl ResolveSymbols for StructDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.type_parameters
+            .iter_mut()
+            .for_each(|tp| tp.resolve_symbols(handler, ctx.by_ref()));
+        self.fields
+            .iter_mut()
+            .for_each(|f| f.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for StructField {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        self.type_argument.resolve_symbols(handler, ctx);
+    }
+}
+
+impl ResolveSymbols for EnumDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.type_parameters
+            .iter_mut()
+            .for_each(|tp| tp.resolve_symbols(handler, ctx.by_ref()));
+        self.variants
+            .iter_mut()
+            .for_each(|f| f.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for EnumVariant {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        self.type_argument.resolve_symbols(handler, ctx);
+    }
+}
+
+impl ResolveSymbols for TraitDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.supertraits
+            .iter_mut()
+            .for_each(|st| st.resolve_symbols(handler, ctx.by_ref()));
+        self.interface_surface
+            .iter_mut()
+            .for_each(|item| item.resolve_symbols(handler, ctx.by_ref()));
+        self.methods
+            .iter_mut()
+            .for_each(|m| m.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for AbiDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.supertraits
+            .iter_mut()
+            .for_each(|st| st.resolve_symbols(handler, ctx.by_ref()));
+        self.interface_surface
+            .iter_mut()
+            .for_each(|item| item.resolve_symbols(handler, ctx.by_ref()));
+        self.methods
+            .iter_mut()
+            .for_each(|m| m.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for TraitItem {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        match self {
+            TraitItem::TraitFn(ref mut id) => id.resolve_symbols(handler, ctx.by_ref()),
+            TraitItem::Constant(ref mut id) => id.resolve_symbols(handler, ctx.by_ref()),
+            TraitItem::Type(ref mut id) => id.resolve_symbols(handler, ctx.by_ref()),
+            TraitItem::Error(_, _) => {}
+        }
+    }
+}
+
+impl ResolveSymbols for TraitFn {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.parameters
+            .iter_mut()
+            .for_each(|f| f.resolve_symbols(handler, ctx.by_ref()));
+        self.return_type.resolve_symbols(handler, ctx.by_ref());
+    }
+}
+
+impl ResolveSymbols for Supertrait {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.name.resolve_symbols(handler, ctx.by_ref());
+    }
+}
+
+impl ResolveSymbols for FunctionParameter {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.type_argument.resolve_symbols(handler, ctx.by_ref());
+    }
+}
+
+impl ResolveSymbols for ImplSelfOrTrait {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.impl_type_parameters
+            .iter_mut()
+            .for_each(|f| f.resolve_symbols(handler, ctx.by_ref()));
+        self.trait_name.resolve_symbols(handler, ctx.by_ref());
+        self.trait_type_arguments
+            .iter_mut()
+            .for_each(|tp| tp.resolve_symbols(handler, ctx.by_ref()));
+        self.implementing_for.resolve_symbols(handler, ctx.by_ref());
+        self.items
+            .iter_mut()
+            .for_each(|tp| tp.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for ImplItem {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        match self {
+            ImplItem::Fn(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            ImplItem::Constant(decl_id) => decl_id.resolve_symbols(handler, ctx),
+            ImplItem::Type(decl_id) => decl_id.resolve_symbols(handler, ctx),
+        }
+    }
+}
+
+impl ResolveSymbols for TraitTypeDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        if let Some(ty) = self.ty_opt.as_mut() {
+            ty.resolve_symbols(handler, ctx)
+        }
+    }
+}
+
+impl ResolveSymbols for StorageDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.entries
+            .iter_mut()
+            .for_each(|e| e.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for StorageEntry {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        match self {
+            StorageEntry::Namespace(ref mut ns) => {
+                ns.entries
+                    .iter_mut()
+                    .for_each(|e| e.resolve_symbols(handler, ctx.by_ref()));
+            }
+            StorageEntry::Field(ref mut f) => {
+                f.type_argument.resolve_symbols(handler, ctx.by_ref());
+                f.initializer.resolve_symbols(handler, ctx.by_ref());
+            }
+        }
+    }
+}
+
+impl ResolveSymbols for TypeAliasDeclaration {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        self.ty.resolve_symbols(handler, ctx)
+    }
+}
+
+impl ResolveSymbols for TypeArgument {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        if let Some(call_path) = self.call_path_tree.as_mut() {
+            call_path.resolve_symbols(handler, ctx);
+        }
+    }
+}
+
+impl ResolveSymbols for TypeParameter {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.trait_constraints
+            .iter_mut()
+            .for_each(|tc| tc.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for TraitConstraint {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        self.trait_name.resolve_symbols(handler, ctx.by_ref());
+        self.type_arguments
+            .iter_mut()
+            .for_each(|tc| tc.resolve_symbols(handler, ctx.by_ref()));
+    }
+}
+
+impl ResolveSymbols for CallPath {
+    fn resolve_symbols(&mut self, _handler: &Handler, _ctx: SymbolResolveContext) {}
+}
+
+impl ResolveSymbols for CallPathTree {
+    fn resolve_symbols(&mut self, _handler: &Handler, _ctx: SymbolResolveContext) {}
+}
+
+impl ResolveSymbols for CodeBlock {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        for expr in self.contents.iter_mut() {
+            expr.resolve_symbols(handler, ctx.by_ref())
+        }
+    }
+}
+
+impl ResolveSymbols for StructExpressionField {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        self.value.resolve_symbols(handler, ctx);
+    }
+}
+
+impl ResolveSymbols for Scrutinee {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        match self {
+            Scrutinee::Or {
+                ref mut elems,
+                span: _,
+            } => elems
+                .iter_mut()
+                .for_each(|e| e.resolve_symbols(handler, ctx.by_ref())),
+            Scrutinee::CatchAll { .. } => {}
+            Scrutinee::Literal { .. } => {}
+            Scrutinee::Variable { .. } => {}
+            Scrutinee::AmbiguousSingleIdent(_) => {}
+            Scrutinee::StructScrutinee {
+                struct_name,
+                fields,
+                span: _,
+            } => {
+                struct_name.resolve_symbols(handler, ctx.by_ref());
+                fields
+                    .iter_mut()
+                    .for_each(|f| f.resolve_symbols(handler, ctx.by_ref()))
+            }
+            Scrutinee::EnumScrutinee {
+                call_path,
+                value,
+                span: _,
+            } => {
+                call_path.resolve_symbols(handler, ctx.by_ref());
+                value.resolve_symbols(handler, ctx.by_ref());
+            }
+            Scrutinee::Tuple { elems, span: _ } => {
+                elems
+                    .iter_mut()
+                    .for_each(|s| s.resolve_symbols(handler, ctx.by_ref()));
+            }
+            Scrutinee::Error { .. } => {}
+        }
+    }
+}
+
+impl ResolveSymbols for StructScrutineeField {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        match self {
+            StructScrutineeField::Rest { .. } => {}
+            StructScrutineeField::Field {
+                field: _,
+                scrutinee,
+                span: _,
+            } => {
+                if let Some(scrutinee) = scrutinee.as_mut() {
+                    scrutinee.resolve_symbols(handler, ctx.by_ref());
+                }
+            }
+        }
+    }
+}
+
+impl ResolveSymbols for Expression {
+    fn resolve_symbols(&mut self, handler: &Handler, ctx: SymbolResolveContext) {
+        self.kind.resolve_symbols(handler, ctx);
+    }
+}
+
+impl ResolveSymbols for ExpressionKind {
+    fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext) {
+        match self {
+            ExpressionKind::Error(_, _) => {}
+            ExpressionKind::Literal(_) => {}
+            ExpressionKind::AmbiguousPathExpression(_) => {}
+            ExpressionKind::FunctionApplication(expr) => {
+                let result = SymbolResolveTypeBinding::resolve_symbol(
+                    &mut expr.call_path_binding,
+                    &Handler::default(),
+                    ctx.by_ref(),
+                );
+                if let Ok(result) = result {
+                    expr.resolved_call_path_binding = Some(TypeBinding::<
+                        ResolvedCallPath<ParsedDeclId<FunctionDeclaration>>,
+                    > {
+                        inner: ResolvedCallPath {
+                            decl: result,
+                            unresolved_call_path: expr.call_path_binding.inner.clone(),
+                        },
+                        span: expr.call_path_binding.span.clone(),
+                        type_arguments: expr.call_path_binding.type_arguments.clone(),
+                    });
+                }
+                expr.arguments
+                    .iter_mut()
+                    .for_each(|a| a.resolve_symbols(handler, ctx.by_ref()))
+            }
+            ExpressionKind::LazyOperator(expr) => {
+                expr.lhs.resolve_symbols(handler, ctx.by_ref());
+                expr.rhs.resolve_symbols(handler, ctx.by_ref());
+            }
+            ExpressionKind::AmbiguousVariableExpression(_) => {}
+            ExpressionKind::Variable(_) => {}
+            ExpressionKind::Tuple(exprs) => {
+                exprs
+                    .iter_mut()
+                    .for_each(|expr| expr.resolve_symbols(handler, ctx.by_ref()));
+            }
+            ExpressionKind::TupleIndex(expr) => {
+                expr.prefix.resolve_symbols(handler, ctx.by_ref());
+            }
+            ExpressionKind::Array(expr) => expr
+                .contents
+                .iter_mut()
+                .for_each(|e| e.resolve_symbols(handler, ctx.by_ref())),
+            ExpressionKind::Struct(expr) => {
+                expr.call_path_binding
+                    .resolve_symbols(handler, ctx.by_ref());
+                let result = SymbolResolveTypeBinding::resolve_symbol(
+                    &mut expr.call_path_binding,
+                    &Handler::default(),
+                    ctx.by_ref(),
+                );
+                if let Ok(result) = result {
+                    expr.resolved_call_path_binding = Some(TypeBinding::<
+                        ResolvedCallPath<ParsedDeclId<StructDeclaration>>,
+                    > {
+                        inner: ResolvedCallPath {
+                            decl: result,
+                            unresolved_call_path: expr.call_path_binding.inner.clone(),
+                        },
+                        span: expr.call_path_binding.span.clone(),
+                        type_arguments: expr.call_path_binding.type_arguments.clone(),
+                    });
+                }
+            }
+            ExpressionKind::CodeBlock(block) => {
+                block
+                    .contents
+                    .iter_mut()
+                    .for_each(|node| node.resolve_symbols(handler, ctx.by_ref()));
+            }
+            ExpressionKind::If(expr) => {
+                expr.condition.resolve_symbols(handler, ctx.by_ref());
+                expr.then.resolve_symbols(handler, ctx.by_ref());
+                if let Some(r#else) = expr.r#else.as_mut() {
+                    r#else.resolve_symbols(handler, ctx.by_ref());
+                }
+            }
+            ExpressionKind::Match(expr) => {
+                expr.value.resolve_symbols(handler, ctx.by_ref());
+                expr.branches.iter_mut().for_each(|branch| {
+                    branch.scrutinee.resolve_symbols(handler, ctx.by_ref());
+                    branch.result.resolve_symbols(handler, ctx.by_ref());
+                });
+            }
+            ExpressionKind::Asm(asm_expr) => asm_expr.registers.iter_mut().for_each(|reg| {
+                if let Some(initializer) = reg.initializer.as_mut() {
+                    initializer.resolve_symbols(handler, ctx.by_ref());
+                }
+            }),
+            ExpressionKind::MethodApplication(expr) => {
+                expr.method_name_binding
+                    .resolve_symbols(handler, ctx.by_ref());
+                expr.contract_call_params
+                    .iter_mut()
+                    .for_each(|field| field.resolve_symbols(handler, ctx.by_ref()));
+                expr.arguments
+                    .iter_mut()
+                    .for_each(|arg| arg.resolve_symbols(handler, ctx.by_ref()));
+            }
+            ExpressionKind::Subfield(expr) => expr.prefix.resolve_symbols(handler, ctx),
+            ExpressionKind::DelineatedPath(expr) => {
+                expr.call_path_binding.resolve_symbols(handler, ctx)
+            }
+            ExpressionKind::AbiCast(expr) => {
+                expr.abi_name.resolve_symbols(handler, ctx.by_ref());
+                expr.address.resolve_symbols(handler, ctx.by_ref());
+            }
+            ExpressionKind::ArrayIndex(expr) => {
+                expr.index.resolve_symbols(handler, ctx.by_ref());
+                expr.prefix.resolve_symbols(handler, ctx.by_ref());
+            }
+            ExpressionKind::StorageAccess(_expr) => {}
+            ExpressionKind::IntrinsicFunction(expr) => {
+                expr.arguments
+                    .iter_mut()
+                    .for_each(|arg| arg.resolve_symbols(handler, ctx.by_ref()));
+                expr.kind_binding.resolve_symbols(handler, ctx);
+            }
+            ExpressionKind::WhileLoop(expr) => {
+                expr.condition.resolve_symbols(handler, ctx.by_ref());
+                expr.body.resolve_symbols(handler, ctx.by_ref());
+            }
+            ExpressionKind::ForLoop(expr) => expr.desugared.resolve_symbols(handler, ctx.by_ref()),
+            ExpressionKind::Break => {}
+            ExpressionKind::Continue => {}
+            ExpressionKind::Reassignment(expr) => {
+                match &mut expr.lhs {
+                    ReassignmentTarget::ElementAccess(expr) => {
+                        expr.resolve_symbols(handler, ctx.by_ref())
+                    }
+                    ReassignmentTarget::Deref(expr) => expr.resolve_symbols(handler, ctx.by_ref()),
+                };
+                expr.rhs.resolve_symbols(handler, ctx.by_ref());
+            }
+            ExpressionKind::ImplicitReturn(expr) => expr.resolve_symbols(handler, ctx),
+            ExpressionKind::Return(expr) => expr.resolve_symbols(handler, ctx.by_ref()),
+            ExpressionKind::Ref(expr) => expr.value.resolve_symbols(handler, ctx.by_ref()),
+            ExpressionKind::Deref(expr) => expr.resolve_symbols(handler, ctx.by_ref()),
+        }
+    }
+}
diff --git a/sway-core/src/semantic_analysis/symbol_resolve_context.rs b/sway-core/src/semantic_analysis/symbol_resolve_context.rs
new file mode 100644
index 00000000000..01bc631ec0e
--- /dev/null
+++ b/sway-core/src/semantic_analysis/symbol_resolve_context.rs
@@ -0,0 +1,253 @@
+use crate::{
+    engine_threading::*,
+    language::{CallPath, Visibility},
+    namespace::{ModulePath, ResolvedDeclaration},
+    semantic_analysis::{ast_node::ConstShadowingMode, Namespace},
+    type_system::TypeId,
+};
+use sway_error::{
+    error::CompileError,
+    handler::{ErrorEmitted, Handler},
+};
+use sway_types::{span::Span, Ident, Spanned};
+use sway_utils::iter_prefixes;
+
+use super::{symbol_collection_context::SymbolCollectionContext, GenericShadowingMode};
+
+/// Contextual state tracked and accumulated throughout symbol resolving.
+pub struct SymbolResolveContext<'a> {
+    /// The namespace context accumulated throughout symbol resolving.
+    ///
+    /// Internally, this includes:
+    ///
+    /// - The `root` module from which all other modules maybe be accessed using absolute paths.
+    /// - The `init` module used to initialize submodule namespaces.
+    /// - A `mod_path` that represents the current module being type-checked. This is automatically
+    ///   updated upon entering/exiting submodules via the `enter_submodule` method.
+    pub(crate) engines: &'a Engines,
+    pub(crate) symbol_collection_ctx: &'a mut SymbolCollectionContext,
+
+    // The following set of fields are intentionally private. When a `SymbolResolveContext` is passed
+    // into a new node during symbol resolving, these fields should be updated using the `with_*`
+    // methods which provides a new `SymbolResolveContext`, ensuring we don't leak our changes into
+    // the parent nodes.
+    /// While symbol resolving an `impl` (whether inherent or for a `trait`/`abi`) this represents the
+    /// type for which we are implementing. For example in `impl Foo {}` or `impl Trait for Foo
+    /// {}`, this represents the type ID of `Foo`.
+    self_type: Option<TypeId>,
+    /// Whether or not a const declaration shadows previous const declarations sequentially.
+    ///
+    /// This is `Sequential` while checking const declarations in functions, otherwise `ItemStyle`.
+    const_shadowing_mode: ConstShadowingMode,
+    /// Whether or not a generic type parameters shadows previous generic type parameters.
+    ///
+    /// This is `Disallow` everywhere except while checking type parameters bounds in struct instantiation.
+    generic_shadowing_mode: GenericShadowingMode,
+}
+
+impl<'a> SymbolResolveContext<'a> {
+    /// Initialize a symbol resolving context with a namespace.
+    pub fn new(
+        engines: &'a Engines,
+        symbol_collection_ctx: &'a mut SymbolCollectionContext,
+    ) -> Self {
+        Self {
+            engines,
+            symbol_collection_ctx,
+            self_type: None,
+            const_shadowing_mode: ConstShadowingMode::ItemStyle,
+            generic_shadowing_mode: GenericShadowingMode::Disallow,
+        }
+    }
+
+    /// Create a new context that mutably borrows the inner `namespace` with a lifetime bound by
+    /// `self`.
+    ///
+    /// This is particularly useful when symbol resolving a node that has more than one child node
+    /// (very often the case). By taking the context with the namespace lifetime bound to `self`
+    /// rather than the original namespace reference, we instead restrict the returned context to
+    /// the local scope and avoid consuming the original context when providing context to the
+    /// first visited child node.
+    pub fn by_ref(&mut self) -> SymbolResolveContext<'_> {
+        SymbolResolveContext {
+            engines: self.engines,
+            symbol_collection_ctx: self.symbol_collection_ctx,
+            self_type: self.self_type,
+            const_shadowing_mode: self.const_shadowing_mode,
+            generic_shadowing_mode: self.generic_shadowing_mode,
+        }
+    }
+
+    /// Scope the `SymbolResolveContext` with a new namespace lexical scope.
+    pub fn enter_lexical_scope<T>(
+        self,
+        handler: &Handler,
+        span: Span,
+        with_scoped_ctx: impl FnOnce(SymbolResolveContext) -> Result<T, ErrorEmitted>,
+    ) -> Result<T, ErrorEmitted> {
+        let engines = self.engines;
+        self.symbol_collection_ctx.enter_lexical_scope(
+            handler,
+            engines,
+            span,
+            |sub_scope_collect_ctx| {
+                let sub_scope_resolve_ctx =
+                    SymbolResolveContext::new(engines, sub_scope_collect_ctx);
+                with_scoped_ctx(sub_scope_resolve_ctx)
+            },
+        )
+    }
+
+    /// Enter the submodule with the given name and a symbol resolve context ready for
+    /// symbol resolving its content.
+    ///
+    /// Returns the result of the given `with_submod_ctx` function.
+    pub fn enter_submodule<T>(
+        self,
+        mod_name: Ident,
+        visibility: Visibility,
+        module_span: Span,
+        with_submod_ctx: impl FnOnce(SymbolResolveContext) -> T,
+    ) -> T {
+        let engines = self.engines;
+        self.symbol_collection_ctx.enter_submodule(
+            engines,
+            mod_name,
+            visibility,
+            module_span,
+            |submod_collect_ctx| {
+                let submod_ctx = SymbolResolveContext::new(engines, submod_collect_ctx);
+                with_submod_ctx(submod_ctx)
+            },
+        )
+    }
+
+    /// Returns a mutable reference to the current namespace.
+    pub fn namespace_mut(&mut self) -> &mut Namespace {
+        &mut self.symbol_collection_ctx.namespace
+    }
+
+    /// Returns a reference to the current namespace.
+    pub fn namespace(&self) -> &Namespace {
+        &self.symbol_collection_ctx.namespace
+    }
+
+    /// Map this `SymbolResolveContext` instance to a new one with the given const shadowing `mode`.
+    #[allow(unused)]
+    pub(crate) fn with_const_shadowing_mode(
+        self,
+        const_shadowing_mode: ConstShadowingMode,
+    ) -> Self {
+        Self {
+            const_shadowing_mode,
+            ..self
+        }
+    }
+
+    /// Map this `SymbolResolveContext` instance to a new one with the given generic shadowing `mode`.
+    #[allow(unused)]
+    pub(crate) fn with_generic_shadowing_mode(
+        self,
+        generic_shadowing_mode: GenericShadowingMode,
+    ) -> Self {
+        Self {
+            generic_shadowing_mode,
+            ..self
+        }
+    }
+
+    // A set of accessor methods. We do this rather than making the fields `pub` in order to ensure
+    // that these are only updated via the `with_*` methods that produce a new `SymbolResolveContext`.
+    #[allow(unused)]
+    pub(crate) fn self_type(&self) -> Option<TypeId> {
+        self.self_type
+    }
+
+    #[allow(unused)]
+    pub(crate) fn const_shadowing_mode(&self) -> ConstShadowingMode {
+        self.const_shadowing_mode
+    }
+
+    #[allow(unused)]
+    pub(crate) fn generic_shadowing_mode(&self) -> GenericShadowingMode {
+        self.generic_shadowing_mode
+    }
+
+    /// Get the engines needed for engine threading.
+    pub(crate) fn engines(&self) -> &'a Engines {
+        self.engines
+    }
+
+    /// Short-hand for calling [Root::resolve_call_path_with_visibility_check] on `root` with the `mod_path`.
+    pub(crate) fn resolve_call_path_with_visibility_check(
+        &self,
+        handler: &Handler,
+        call_path: &CallPath,
+    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
+        self.resolve_call_path_with_visibility_check_and_modpath(
+            handler,
+            &self.namespace().mod_path,
+            call_path,
+        )
+    }
+
+    /// Resolve a symbol that is potentially prefixed with some path, e.g. `foo::bar::symbol`.
+    ///
+    /// This will concatenate the `mod_path` with the `call_path`'s prefixes and
+    /// then calling `resolve_symbol` with the resulting path and call_path's suffix.
+    ///
+    /// The `mod_path` is significant here as we assume the resolution is done within the
+    /// context of the module pointed to by `mod_path` and will only check the call path prefixes
+    /// and the symbol's own visibility.
+    pub(crate) fn resolve_call_path_with_visibility_check_and_modpath(
+        &self,
+        handler: &Handler,
+        mod_path: &ModulePath,
+        call_path: &CallPath,
+    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
+        let (decl, mod_path) = self.namespace().root.resolve_call_path_and_mod_path(
+            handler,
+            self.engines,
+            mod_path,
+            call_path,
+            self.self_type,
+        )?;
+
+        // In case there is no mod path we don't need to check visibility
+        if mod_path.is_empty() {
+            return Ok(decl);
+        }
+
+        // In case there are no prefixes we don't need to check visibility
+        if call_path.prefixes.is_empty() {
+            return Ok(decl);
+        }
+
+        // check the visibility of the call path elements
+        // we don't check the first prefix because direct children are always accessible
+        for prefix in iter_prefixes(&call_path.prefixes).skip(1) {
+            let module = self.namespace().lookup_submodule_from_absolute_path(
+                handler,
+                self.engines(),
+                prefix,
+            )?;
+            if module.visibility().is_private() {
+                let prefix_last = prefix[prefix.len() - 1].clone();
+                handler.emit_err(CompileError::ImportPrivateModule {
+                    span: prefix_last.span(),
+                    name: prefix_last,
+                });
+            }
+        }
+
+        // check the visibility of the symbol itself
+        if !decl.visibility(self.engines).is_public() {
+            handler.emit_err(CompileError::ImportPrivateSymbol {
+                name: call_path.suffix.clone(),
+                span: call_path.suffix.span(),
+            });
+        }
+
+        Ok(decl)
+    }
+}
diff --git a/sway-core/src/semantic_analysis/type_check_analysis.rs b/sway-core/src/semantic_analysis/type_check_analysis.rs
index 41b260538de..6ad5337561d 100644
--- a/sway-core/src/semantic_analysis/type_check_analysis.rs
+++ b/sway-core/src/semantic_analysis/type_check_analysis.rs
@@ -38,7 +38,7 @@ impl Display for TyNodeDepGraphEdge {
 
 #[derive(Clone, Debug)]
 pub enum TyNodeDepGraphNode {
-    ImplTrait { node: ty::ImplTrait },
+    ImplTrait { node: ty::ImplSelfOrTrait },
     ImplTraitItem { node: ty::TyTraitItem },
     Fn { node: DeclId<TyFunctionDecl> },
 }
@@ -125,7 +125,7 @@ impl TypeCheckAnalysisContext<'_> {
     #[allow(clippy::map_entry)]
     pub(crate) fn push_nodes_for_impl_trait(
         &mut self,
-        impl_trait: &ty::ImplTrait,
+        impl_trait: &ty::ImplSelfOrTrait,
     ) -> TyNodeDepGraphNodeId {
         if self.nodes.contains_key(&impl_trait.decl_id.unique_id()) {
             *self.nodes.get(&impl_trait.decl_id.unique_id()).unwrap()
@@ -136,7 +136,7 @@ impl TypeCheckAnalysisContext<'_> {
             self.nodes.insert(impl_trait.decl_id.unique_id(), node);
 
             let decl_engine = self.engines.de();
-            let impl_trait = decl_engine.get_impl_trait(&impl_trait.decl_id);
+            let impl_trait = decl_engine.get_impl_self_or_trait(&impl_trait.decl_id);
 
             for item in impl_trait.items.iter() {
                 let item_node = self.get_or_create_node_for_impl_item(item);
@@ -372,7 +372,7 @@ impl DebugWithEngines for TyNodeDepGraphNode {
                 format!("{:?}", str)
             }
             TyNodeDepGraphNode::ImplTrait { node } => {
-                let decl = engines.de().get_impl_trait(&node.decl_id);
+                let decl = engines.de().get_impl_self_or_trait(&node.decl_id);
                 format!("{:?}", decl.name().as_str())
             }
             TyNodeDepGraphNode::Fn { node } => {
diff --git a/sway-core/src/semantic_analysis/type_check_context.rs b/sway-core/src/semantic_analysis/type_check_context.rs
index 5703283523d..455cc21fb4b 100644
--- a/sway-core/src/semantic_analysis/type_check_context.rs
+++ b/sway-core/src/semantic_analysis/type_check_context.rs
@@ -2,13 +2,14 @@ use std::collections::{HashMap, VecDeque};
 
 use crate::{
     build_config::ExperimentalFlags,
-    decl_engine::{DeclEngineGet, DeclEngineInsert, DeclRefFunction},
+    decl_engine::{DeclEngineGet, DeclRefFunction},
     engine_threading::*,
     language::{
         parsed::TreeType,
-        ty::{self, TyDecl, TyTraitItem},
-        CallPath, Purity, QualifiedCallPath, Visibility,
+        ty::{self, TyDecl},
+        CallPath, QualifiedCallPath, Visibility,
     },
+    monomorphization::{monomorphize_with_modpath, MonomorphizeHelper},
     namespace::{
         IsExtendingExistingImpl, IsImplSelf, ModulePath, ResolvedDeclaration,
         ResolvedTraitImplItem, TraitMap, TryInsertingTraitImplOnFailure,
@@ -18,16 +19,19 @@ use crate::{
         Namespace,
     },
     type_system::{SubstTypes, TypeArgument, TypeId, TypeInfo},
-    CreateTypeId, TraitConstraint, TypeParameter, TypeSubstMap, UnifyCheck,
+    EnforceTypeArguments, SubstTypesContext, TraitConstraint, TypeSubstMap, UnifyCheck,
 };
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
 };
 use sway_types::{span::Span, Ident, Spanned};
-use sway_utils::iter_prefixes;
 
-use super::GenericShadowingMode;
+use super::{
+    symbol_collection_context::SymbolCollectionContext,
+    type_resolve::{resolve_call_path, resolve_qualified_call_path, resolve_type},
+    GenericShadowingMode,
+};
 
 /// Contextual state tracked and accumulated throughout type-checking.
 pub struct TypeCheckContext<'a> {
@@ -43,6 +47,12 @@ pub struct TypeCheckContext<'a> {
 
     pub(crate) engines: &'a Engines,
 
+    /// Set of experimental flags.
+    pub(crate) experimental: ExperimentalFlags,
+
+    /// Keeps the accumulated symbols previously collected.
+    pub(crate) collection_ctx: &'a mut SymbolCollectionContext,
+
     // The following set of fields are intentionally private. When a `TypeCheckContext` is passed
     // into a new node during type checking, these fields should be updated using the `with_*`
     // methods which provides a new `TypeCheckContext`, ensuring we don't leak our changes into
@@ -80,9 +90,6 @@ pub struct TypeCheckContext<'a> {
     // TODO: We probably shouldn't carry this through the `Context`, but instead pass it directly
     // to `unify` as necessary?
     help_text: &'static str,
-    /// Tracks the purity of the context, e.g. whether or not we should be allowed to write to
-    /// storage.
-    purity: Purity,
     /// Provides the kind of the module.
     /// This is useful for example to throw an error when while loops are present in predicates.
     kind: TreeType,
@@ -92,29 +99,30 @@ pub struct TypeCheckContext<'a> {
     /// body).
     disallow_functions: bool,
 
-    /// Indicates when semantic analysis should  be deferred for function/method applications.
-    /// This is currently used to perform the final type checking and monomorphization in the
-    /// case of impl trait methods after the initial type checked AST is constructed, and
-    /// after we perform a dependency analysis on the tree.
-    defer_monomorphization: bool,
-
     /// Indicates when semantic analysis is type checking storage declaration.
     storage_declaration: bool,
 
-    /// Set of experimental flags
-    pub experimental: ExperimentalFlags,
+    // Indicates when we are collecting unifications.
+    collecting_unifications: bool,
+
+    // Indicates when we are doing the first pass of the code block type checking.
+    // In some nested places of the first pass we want to disable the first pass optimizations
+    // To disable those optimizations we can set this to false.
+    code_block_first_pass: bool,
 }
 
 impl<'a> TypeCheckContext<'a> {
     /// Initialize a type-checking context with a namespace.
     pub fn from_namespace(
         namespace: &'a mut Namespace,
+        collection_ctx: &'a mut SymbolCollectionContext,
         engines: &'a Engines,
         experimental: ExperimentalFlags,
     ) -> Self {
         Self {
             namespace,
             engines,
+            collection_ctx,
             type_annotation: engines.te().insert(engines, TypeInfo::Unknown, None),
             function_type_annotation: engines.te().insert(engines, TypeInfo::Unknown, None),
             unify_generic: false,
@@ -124,12 +132,12 @@ impl<'a> TypeCheckContext<'a> {
             abi_mode: AbiMode::NonAbi,
             const_shadowing_mode: ConstShadowingMode::ItemStyle,
             generic_shadowing_mode: GenericShadowingMode::Disallow,
-            purity: Purity::default(),
             kind: TreeType::Contract,
             disallow_functions: false,
-            defer_monomorphization: false,
             storage_declaration: false,
             experimental,
+            collecting_unifications: false,
+            code_block_first_pass: false,
         }
     }
 
@@ -140,21 +148,23 @@ impl<'a> TypeCheckContext<'a> {
     /// - type_annotation: unknown
     /// - mode: NoneAbi
     /// - help_text: ""
-    /// - purity: Pure
     pub fn from_root(
         root_namespace: &'a mut Namespace,
+        collection_ctx: &'a mut SymbolCollectionContext,
         engines: &'a Engines,
         experimental: ExperimentalFlags,
     ) -> Self {
-        Self::from_module_namespace(root_namespace, engines, experimental)
+        Self::from_module_namespace(root_namespace, collection_ctx, engines, experimental)
     }
 
     fn from_module_namespace(
         namespace: &'a mut Namespace,
+        collection_ctx: &'a mut SymbolCollectionContext,
         engines: &'a Engines,
         experimental: ExperimentalFlags,
     ) -> Self {
         Self {
+            collection_ctx,
             namespace,
             engines,
             type_annotation: engines.te().insert(engines, TypeInfo::Unknown, None),
@@ -166,12 +176,12 @@ impl<'a> TypeCheckContext<'a> {
             abi_mode: AbiMode::NonAbi,
             const_shadowing_mode: ConstShadowingMode::ItemStyle,
             generic_shadowing_mode: GenericShadowingMode::Disallow,
-            purity: Purity::default(),
             kind: TreeType::Contract,
             disallow_functions: false,
-            defer_monomorphization: false,
             storage_declaration: false,
             experimental,
+            collecting_unifications: false,
+            code_block_first_pass: false,
         }
     }
 
@@ -186,6 +196,7 @@ impl<'a> TypeCheckContext<'a> {
     pub fn by_ref(&mut self) -> TypeCheckContext<'_> {
         TypeCheckContext {
             namespace: self.namespace,
+            collection_ctx: self.collection_ctx,
             type_annotation: self.type_annotation,
             function_type_annotation: self.function_type_annotation,
             unify_generic: self.unify_generic,
@@ -195,70 +206,141 @@ impl<'a> TypeCheckContext<'a> {
             const_shadowing_mode: self.const_shadowing_mode,
             generic_shadowing_mode: self.generic_shadowing_mode,
             help_text: self.help_text,
-            purity: self.purity,
             kind: self.kind,
             engines: self.engines,
             disallow_functions: self.disallow_functions,
-            defer_monomorphization: self.defer_monomorphization,
             storage_declaration: self.storage_declaration,
             experimental: self.experimental,
+            collecting_unifications: self.collecting_unifications,
+            code_block_first_pass: self.code_block_first_pass,
         }
     }
 
-    /// Scope the `TypeCheckContext` with a new namespace.
+    /// Scope the `TypeCheckContext` with a new namespace, and set up the collection context
+    /// so it enters the lexical scope corresponding to the given span.
     pub fn scoped<T>(
         self,
+        handler: &Handler,
+        span: Option<Span>,
         with_scoped_ctx: impl FnOnce(TypeCheckContext) -> Result<T, ErrorEmitted>,
     ) -> Result<T, ErrorEmitted> {
         let mut namespace = self.namespace.clone();
-        let ctx = TypeCheckContext {
-            namespace: &mut namespace,
-            type_annotation: self.type_annotation,
-            function_type_annotation: self.function_type_annotation,
-            unify_generic: self.unify_generic,
-            self_type: self.self_type,
-            type_subst: self.type_subst,
-            abi_mode: self.abi_mode,
-            const_shadowing_mode: self.const_shadowing_mode,
-            generic_shadowing_mode: self.generic_shadowing_mode,
-            help_text: self.help_text,
-            purity: self.purity,
-            kind: self.kind,
-            engines: self.engines,
-            disallow_functions: self.disallow_functions,
-            defer_monomorphization: self.defer_monomorphization,
-            storage_declaration: self.storage_declaration,
-            experimental: self.experimental,
-        };
-        with_scoped_ctx(ctx)
+        if let Some(span) = span {
+            self.collection_ctx.enter_lexical_scope(
+                handler,
+                self.engines,
+                span,
+                |scoped_collection_ctx| {
+                    let ctx = TypeCheckContext {
+                        namespace: &mut namespace,
+                        collection_ctx: scoped_collection_ctx,
+                        type_annotation: self.type_annotation,
+                        function_type_annotation: self.function_type_annotation,
+                        unify_generic: self.unify_generic,
+                        self_type: self.self_type,
+                        type_subst: self.type_subst,
+                        abi_mode: self.abi_mode,
+                        const_shadowing_mode: self.const_shadowing_mode,
+                        generic_shadowing_mode: self.generic_shadowing_mode,
+                        help_text: self.help_text,
+                        kind: self.kind,
+                        engines: self.engines,
+                        disallow_functions: self.disallow_functions,
+                        storage_declaration: self.storage_declaration,
+                        experimental: self.experimental,
+                        collecting_unifications: self.collecting_unifications,
+                        code_block_first_pass: self.code_block_first_pass,
+                    };
+                    with_scoped_ctx(ctx)
+                },
+            )
+        } else {
+            let ctx = TypeCheckContext {
+                collection_ctx: self.collection_ctx,
+                namespace: &mut namespace,
+                type_annotation: self.type_annotation,
+                function_type_annotation: self.function_type_annotation,
+                unify_generic: self.unify_generic,
+                self_type: self.self_type,
+                type_subst: self.type_subst,
+                abi_mode: self.abi_mode,
+                const_shadowing_mode: self.const_shadowing_mode,
+                generic_shadowing_mode: self.generic_shadowing_mode,
+                help_text: self.help_text,
+                kind: self.kind,
+                engines: self.engines,
+                disallow_functions: self.disallow_functions,
+                storage_declaration: self.storage_declaration,
+                experimental: self.experimental,
+                collecting_unifications: self.collecting_unifications,
+                code_block_first_pass: self.code_block_first_pass,
+            };
+            with_scoped_ctx(ctx)
+        }
     }
 
     /// Scope the `TypeCheckContext` with a new namespace and returns it in case of success.
+    /// Also sets up the collection context so it enters the lexical scope corresponding to
+    /// the given span.
     pub fn scoped_and_namespace<T>(
         self,
+        handler: &Handler,
+        span: Option<Span>,
         with_scoped_ctx: impl FnOnce(TypeCheckContext) -> Result<T, ErrorEmitted>,
     ) -> Result<(T, Namespace), ErrorEmitted> {
         let mut namespace = self.namespace.clone();
-        let ctx = TypeCheckContext {
-            namespace: &mut namespace,
-            type_annotation: self.type_annotation,
-            function_type_annotation: self.function_type_annotation,
-            unify_generic: self.unify_generic,
-            self_type: self.self_type,
-            type_subst: self.type_subst,
-            abi_mode: self.abi_mode,
-            const_shadowing_mode: self.const_shadowing_mode,
-            generic_shadowing_mode: self.generic_shadowing_mode,
-            help_text: self.help_text,
-            purity: self.purity,
-            kind: self.kind,
-            engines: self.engines,
-            disallow_functions: self.disallow_functions,
-            defer_monomorphization: self.defer_monomorphization,
-            storage_declaration: self.storage_declaration,
-            experimental: self.experimental,
-        };
-        Ok((with_scoped_ctx(ctx)?, namespace))
+        if let Some(span) = span {
+            self.collection_ctx.enter_lexical_scope(
+                handler,
+                self.engines,
+                span,
+                |scoped_collection_ctx| {
+                    let ctx = TypeCheckContext {
+                        collection_ctx: scoped_collection_ctx,
+                        namespace: &mut namespace,
+                        type_annotation: self.type_annotation,
+                        function_type_annotation: self.function_type_annotation,
+                        unify_generic: self.unify_generic,
+                        self_type: self.self_type,
+                        type_subst: self.type_subst,
+                        abi_mode: self.abi_mode,
+                        const_shadowing_mode: self.const_shadowing_mode,
+                        generic_shadowing_mode: self.generic_shadowing_mode,
+                        help_text: self.help_text,
+                        kind: self.kind,
+                        engines: self.engines,
+                        disallow_functions: self.disallow_functions,
+                        storage_declaration: self.storage_declaration,
+                        experimental: self.experimental,
+                        collecting_unifications: self.collecting_unifications,
+                        code_block_first_pass: self.code_block_first_pass,
+                    };
+                    Ok((with_scoped_ctx(ctx)?, namespace))
+                },
+            )
+        } else {
+            let ctx = TypeCheckContext {
+                collection_ctx: self.collection_ctx,
+                namespace: &mut namespace,
+                type_annotation: self.type_annotation,
+                function_type_annotation: self.function_type_annotation,
+                unify_generic: self.unify_generic,
+                self_type: self.self_type,
+                type_subst: self.type_subst,
+                abi_mode: self.abi_mode,
+                const_shadowing_mode: self.const_shadowing_mode,
+                generic_shadowing_mode: self.generic_shadowing_mode,
+                help_text: self.help_text,
+                kind: self.kind,
+                engines: self.engines,
+                disallow_functions: self.disallow_functions,
+                storage_declaration: self.storage_declaration,
+                experimental: self.experimental,
+                collecting_unifications: self.collecting_unifications,
+                code_block_first_pass: self.code_block_first_pass,
+            };
+            Ok((with_scoped_ctx(ctx)?, namespace))
+        }
     }
 
     /// Enter the submodule with the given name and produce a type-check context ready for
@@ -266,7 +348,7 @@ impl<'a> TypeCheckContext<'a> {
     ///
     /// Returns the result of the given `with_submod_ctx` function.
     pub fn enter_submodule<T>(
-        mut self,
+        self,
         mod_name: Ident,
         visibility: Visibility,
         module_span: Span,
@@ -277,11 +359,28 @@ impl<'a> TypeCheckContext<'a> {
         // We're checking a submodule, so no need to pass through anything other than the
         // namespace and the engines.
         let engines = self.engines;
-        let mut submod_ns =
-            self.namespace_mut()
-                .enter_submodule(engines, mod_name, visibility, module_span);
-        let submod_ctx = TypeCheckContext::from_namespace(&mut submod_ns, engines, experimental);
-        with_submod_ctx(submod_ctx)
+        let mut submod_ns = self.namespace.enter_submodule(
+            engines,
+            mod_name.clone(),
+            visibility,
+            module_span.clone(),
+        );
+
+        self.collection_ctx.enter_submodule(
+            engines,
+            mod_name,
+            visibility,
+            module_span,
+            |submod_collection_ctx| {
+                let submod_ctx = TypeCheckContext::from_namespace(
+                    &mut submod_ns,
+                    submod_collection_ctx,
+                    engines,
+                    experimental,
+                );
+                with_submod_ctx(submod_ctx)
+            },
+        )
     }
 
     /// Returns a mutable reference to the current namespace.
@@ -358,21 +457,30 @@ impl<'a> TypeCheckContext<'a> {
         }
     }
 
-    /// Map this `TypeCheckContext` instance to a new one with the given purity.
-    pub(crate) fn with_purity(self, purity: Purity) -> Self {
-        Self { purity, ..self }
-    }
-
     /// Map this `TypeCheckContext` instance to a new one with the given module kind.
     pub(crate) fn with_kind(self, kind: TreeType) -> Self {
         Self { kind, ..self }
     }
 
-    /// Map this `TypeCheckContext` instance to a new one with the given purity.
+    /// Map this `TypeCheckContext` instance to a new one with the given self type.
     pub(crate) fn with_self_type(self, self_type: Option<TypeId>) -> Self {
         Self { self_type, ..self }
     }
 
+    pub(crate) fn with_collecting_unifications(self) -> Self {
+        Self {
+            collecting_unifications: true,
+            ..self
+        }
+    }
+
+    pub(crate) fn with_code_block_first_pass(self, value: bool) -> Self {
+        Self {
+            code_block_first_pass: value,
+            ..self
+        }
+    }
+
     /// Map this `TypeCheckContext` instance to a new one with
     /// `disallow_functions` set to `true`.
     pub(crate) fn disallow_functions(self) -> Self {
@@ -391,15 +499,6 @@ impl<'a> TypeCheckContext<'a> {
         }
     }
 
-    /// Map this `TypeCheckContext` instance to a new one with
-    /// `defer_method_application` set to `true`.
-    pub(crate) fn with_defer_monomorphization(self) -> Self {
-        Self {
-            defer_monomorphization: true,
-            ..self
-        }
-    }
-
     /// Map this `TypeCheckContext` instance to a new one with
     /// `storage_declaration` set to `true`.
     pub(crate) fn with_storage_declaration(self) -> Self {
@@ -432,18 +531,18 @@ impl<'a> TypeCheckContext<'a> {
         self.self_type
     }
 
-    pub(crate) fn type_subst(&self) -> TypeSubstMap {
-        self.type_subst.clone()
+    pub(crate) fn subst_ctx(&self) -> SubstTypesContext {
+        SubstTypesContext::new(
+            self.engines(),
+            &self.type_subst,
+            !self.code_block_first_pass(),
+        )
     }
 
     pub(crate) fn abi_mode(&self) -> AbiMode {
         self.abi_mode.clone()
     }
 
-    pub(crate) fn purity(&self) -> Purity {
-        self.purity
-    }
-
     #[allow(dead_code)]
     pub(crate) fn kind(&self) -> TreeType {
         self.kind
@@ -453,14 +552,23 @@ impl<'a> TypeCheckContext<'a> {
         self.disallow_functions
     }
 
-    pub(crate) fn defer_monomorphization(&self) -> bool {
-        self.defer_monomorphization
-    }
-
     pub(crate) fn storage_declaration(&self) -> bool {
         self.storage_declaration
     }
 
+    pub(crate) fn collecting_unifications(&self) -> bool {
+        self.collecting_unifications
+    }
+
+    pub(crate) fn code_block_first_pass(&self) -> bool {
+        self.code_block_first_pass
+    }
+
+    /// Get the engines needed for engine threading.
+    pub(crate) fn engines(&self) -> &'a Engines {
+        self.engines
+    }
+
     // Provide some convenience functions around the inner context.
 
     /// Short-hand for calling the `monomorphize` function in the type engine
@@ -476,13 +584,17 @@ impl<'a> TypeCheckContext<'a> {
         T: MonomorphizeHelper + SubstTypes,
     {
         let mod_path = self.namespace().mod_path.clone();
-        self.monomorphize_with_modpath(
+        monomorphize_with_modpath(
             handler,
+            self.engines(),
+            self.namespace(),
             value,
             type_arguments,
             enforce_type_arguments,
             call_site_span,
             &mod_path,
+            self.self_type(),
+            &self.subst_ctx(),
         )
     }
 
@@ -522,6 +634,7 @@ impl<'a> TypeCheckContext<'a> {
     ) -> Result<(), ErrorEmitted> {
         let const_shadowing_mode = self.const_shadowing_mode;
         let generic_shadowing_mode = self.generic_shadowing_mode;
+        let collecting_unifications = self.collecting_unifications;
         let engines = self.engines();
         self.namespace_mut()
             .module_mut(engines)
@@ -533,215 +646,30 @@ impl<'a> TypeCheckContext<'a> {
                 ResolvedDeclaration::Typed(item),
                 const_shadowing_mode,
                 generic_shadowing_mode,
+                collecting_unifications,
             )
     }
 
-    /// Get the engines needed for engine threading.
-    pub(crate) fn engines(&self) -> &'a Engines {
-        self.engines
-    }
-
-    /// Resolve the type of the given [TypeId], replacing any instances of
-    /// [TypeInfo::Custom] with either a monomorphized struct, monomorphized
-    /// enum, or a reference to a type parameter.
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn resolve(
-        &mut self,
-        handler: &Handler,
-        type_id: TypeId,
-        span: &Span,
-        enforce_type_arguments: EnforceTypeArguments,
-        type_info_prefix: Option<&ModulePath>,
-        mod_path: &ModulePath,
-    ) -> Result<TypeId, ErrorEmitted> {
-        let engines = self.engines;
-        let type_engine = self.engines.te();
-        let module_path = type_info_prefix.unwrap_or(mod_path);
-        let type_id = match (*type_engine.get(type_id)).clone() {
-            TypeInfo::Custom {
-                qualified_call_path,
-                type_arguments,
-                root_type_id,
-            } => {
-                let type_decl_opt = if let Some(root_type_id) = root_type_id {
-                    self.namespace()
-                        .root
-                        .resolve_call_path_and_root_type_id(
-                            handler,
-                            self.engines,
-                            self.namespace().module(engines),
-                            root_type_id,
-                            None,
-                            &qualified_call_path.clone().to_call_path(handler)?,
-                            self.self_type(),
-                        )
-                        .map(|decl| decl.expect_typed())
-                        .ok()
-                } else {
-                    self.resolve_qualified_call_path_with_visibility_check_and_modpath(
-                        handler,
-                        module_path,
-                        &qualified_call_path,
-                    )
-                    .ok()
-                };
-                self.type_decl_opt_to_type_id(
-                    handler,
-                    type_decl_opt,
-                    &qualified_call_path.call_path,
-                    span,
-                    enforce_type_arguments,
-                    mod_path,
-                    type_arguments.clone(),
-                )?
-            }
-            TypeInfo::Array(mut elem_ty, n) => {
-                elem_ty.type_id = self
-                    .resolve(
-                        handler,
-                        elem_ty.type_id,
-                        span,
-                        enforce_type_arguments,
-                        None,
-                        mod_path,
-                    )
-                    .unwrap_or_else(|err| {
-                        self.engines
-                            .te()
-                            .insert(self.engines, TypeInfo::ErrorRecovery(err), None)
-                    });
-
-                self.engines.te().insert(
-                    self.engines,
-                    TypeInfo::Array(elem_ty.clone(), n.clone()),
-                    elem_ty.span.source_id(),
-                )
-            }
-            TypeInfo::Tuple(mut type_arguments) => {
-                for type_argument in type_arguments.iter_mut() {
-                    type_argument.type_id = self
-                        .resolve(
-                            handler,
-                            type_argument.type_id,
-                            span,
-                            enforce_type_arguments,
-                            None,
-                            mod_path,
-                        )
-                        .unwrap_or_else(|err| {
-                            self.engines.te().insert(
-                                self.engines,
-                                TypeInfo::ErrorRecovery(err),
-                                None,
-                            )
-                        });
-                }
-
-                self.engines.te().insert(
-                    self.engines,
-                    TypeInfo::Tuple(type_arguments),
-                    span.source_id(),
-                )
-            }
-            TypeInfo::TraitType {
-                name,
-                trait_type_id,
-            } => {
-                let item_ref = self.namespace().get_root_trait_item_for_type(
-                    handler,
-                    self.engines,
-                    &name,
-                    trait_type_id,
-                    None,
-                )?;
-                if let ResolvedTraitImplItem::Typed(TyTraitItem::Type(type_ref)) = item_ref {
-                    let type_decl = self.engines.de().get_type(type_ref.id());
-                    if let Some(ty) = &type_decl.ty {
-                        ty.type_id
-                    } else {
-                        type_id
-                    }
-                } else {
-                    return Err(handler.emit_err(CompileError::Internal(
-                        "Expecting associated type",
-                        item_ref.span(self.engines),
-                    )));
-                }
-            }
-            TypeInfo::Ref {
-                referenced_type: mut ty,
-                to_mutable_value,
-            } => {
-                ty.type_id = self
-                    .resolve(
-                        handler,
-                        ty.type_id,
-                        span,
-                        enforce_type_arguments,
-                        None,
-                        mod_path,
-                    )
-                    .unwrap_or_else(|err| {
-                        self.engines
-                            .te()
-                            .insert(self.engines, TypeInfo::ErrorRecovery(err), None)
-                    });
-
-                self.engines.te().insert(
-                    self.engines,
-                    TypeInfo::Ref {
-                        to_mutable_value,
-                        referenced_type: ty.clone(),
-                    },
-                    None,
-                )
-            }
-            _ => type_id,
-        };
-
-        let mut type_id = type_id;
-        type_id.subst(&self.type_subst(), self.engines());
-
-        Ok(type_id)
-    }
-
-    /// Short-hand for calling [Root::resolve_type_with_self] on `root` with the `mod_path`.
-    #[allow(clippy::too_many_arguments)] // TODO: remove lint bypass once private modules are no longer experimental
+    /// Short-hand for calling [resolve_type] on `root` with the `mod_path`.
     pub(crate) fn resolve_type(
-        &mut self,
+        &self,
         handler: &Handler,
         type_id: TypeId,
         span: &Span,
         enforce_type_arguments: EnforceTypeArguments,
         type_info_prefix: Option<&ModulePath>,
     ) -> Result<TypeId, ErrorEmitted> {
-        let mod_path = self.namespace().mod_path.clone();
-        self.resolve(
+        resolve_type(
             handler,
+            self.engines(),
+            self.namespace(),
+            &self.namespace().mod_path,
             type_id,
             span,
             enforce_type_arguments,
             type_info_prefix,
-            &mod_path,
-        )
-    }
-
-    /// Short-hand for calling [Root::resolve_type_without_self] on `root` and with the `mod_path`.
-    pub(crate) fn resolve_type_without_self(
-        &mut self,
-        handler: &Handler,
-        type_id: TypeId,
-        span: &Span,
-        type_info_prefix: Option<&ModulePath>,
-    ) -> Result<TypeId, ErrorEmitted> {
-        let mod_path = self.namespace().mod_path.clone();
-        self.resolve(
-            handler,
-            type_id,
-            span,
-            EnforceTypeArguments::Yes,
-            type_info_prefix,
-            &mod_path,
+            self.self_type(),
+            &self.subst_ctx(),
         )
     }
 
@@ -750,266 +678,33 @@ impl<'a> TypeCheckContext<'a> {
         &self,
         handler: &Handler,
         call_path: &CallPath,
-    ) -> Result<ty::TyDecl, ErrorEmitted> {
-        self.resolve_call_path_with_visibility_check_and_modpath(
+    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
+        resolve_call_path(
             handler,
+            self.engines(),
+            self.namespace(),
             &self.namespace().mod_path,
             call_path,
+            self.self_type(),
         )
     }
 
-    /// Resolve a symbol that is potentially prefixed with some path, e.g. `foo::bar::symbol`.
-    ///
-    /// This will concatenate the `mod_path` with the `call_path`'s prefixes and
-    /// then calling `resolve_symbol` with the resulting path and call_path's suffix.
-    ///
-    /// The `mod_path` is significant here as we assume the resolution is done within the
-    /// context of the module pointed to by `mod_path` and will only check the call path prefixes
-    /// and the symbol's own visibility.
-    pub(crate) fn resolve_call_path_with_visibility_check_and_modpath(
-        &self,
-        handler: &Handler,
-        mod_path: &ModulePath,
-        call_path: &CallPath,
-    ) -> Result<ty::TyDecl, ErrorEmitted> {
-        let engines = self.engines;
-        let (decl, mod_path) = self.namespace().root.resolve_call_path_and_mod_path(
-            handler,
-            self.engines,
-            mod_path,
-            call_path,
-            self.self_type,
-        )?;
-        let decl = decl.expect_typed();
-
-        // In case there is no mod path we don't need to check visibility
-        if mod_path.is_empty() {
-            return Ok(decl);
-        }
-
-        // In case there are no prefixes we don't need to check visibility
-        if call_path.prefixes.is_empty() {
-            return Ok(decl);
-        }
-
-        // check the visibility of the call path elements
-        // we don't check the first prefix because direct children are always accessible
-        for prefix in iter_prefixes(&call_path.prefixes).skip(1) {
-            let module = self
-                .namespace()
-                .lookup_submodule_from_absolute_path(handler, engines, prefix)?;
-            if module.visibility.is_private() {
-                let prefix_last = prefix[prefix.len() - 1].clone();
-                handler.emit_err(CompileError::ImportPrivateModule {
-                    span: prefix_last.span(),
-                    name: prefix_last,
-                });
-            }
-        }
-
-        // check the visibility of the symbol itself
-        if !decl.visibility(self.engines.de()).is_public() {
-            handler.emit_err(CompileError::ImportPrivateSymbol {
-                name: call_path.suffix.clone(),
-                span: call_path.suffix.span(),
-            });
-        }
-
-        Ok(decl)
-    }
-
     pub(crate) fn resolve_qualified_call_path_with_visibility_check(
         &mut self,
         handler: &Handler,
         qualified_call_path: &QualifiedCallPath,
-    ) -> Result<ty::TyDecl, ErrorEmitted> {
-        self.resolve_qualified_call_path_with_visibility_check_and_modpath(
+    ) -> Result<ResolvedDeclaration, ErrorEmitted> {
+        resolve_qualified_call_path(
             handler,
+            self.engines(),
+            self.namespace(),
             &self.namespace().mod_path.clone(),
             qualified_call_path,
+            self.self_type(),
+            &self.subst_ctx(),
         )
     }
 
-    pub(crate) fn resolve_qualified_call_path_with_visibility_check_and_modpath(
-        &mut self,
-        handler: &Handler,
-        mod_path: &ModulePath,
-        qualified_call_path: &QualifiedCallPath,
-    ) -> Result<ty::TyDecl, ErrorEmitted> {
-        let type_engine = self.engines().te();
-        if let Some(qualified_path_root) = qualified_call_path.clone().qualified_path_root {
-            let root_type_id = match &&*type_engine.get(qualified_path_root.ty.type_id) {
-                TypeInfo::Custom {
-                    qualified_call_path,
-                    type_arguments,
-                    ..
-                } => {
-                    let type_decl = self.resolve_call_path_with_visibility_check_and_modpath(
-                        handler,
-                        mod_path,
-                        &qualified_call_path.clone().to_call_path(handler)?,
-                    )?;
-                    self.type_decl_opt_to_type_id(
-                        handler,
-                        Some(type_decl),
-                        &qualified_call_path.call_path,
-                        &qualified_path_root.ty.span(),
-                        EnforceTypeArguments::No,
-                        mod_path,
-                        type_arguments.clone(),
-                    )?
-                }
-                _ => qualified_path_root.ty.type_id,
-            };
-
-            let as_trait_opt = match &&*type_engine.get(qualified_path_root.as_trait) {
-                TypeInfo::Custom {
-                    qualified_call_path: call_path,
-                    ..
-                } => Some(
-                    call_path
-                        .clone()
-                        .to_call_path(handler)?
-                        .to_fullpath(self.engines(), self.namespace()),
-                ),
-                _ => None,
-            };
-
-            self.namespace()
-                .root
-                .resolve_call_path_and_root_type_id(
-                    handler,
-                    self.engines,
-                    &self.namespace().root.module,
-                    root_type_id,
-                    as_trait_opt,
-                    &qualified_call_path.call_path,
-                    self.self_type(),
-                )
-                .map(|decl| decl.expect_typed())
-        } else {
-            self.resolve_call_path_with_visibility_check_and_modpath(
-                handler,
-                mod_path,
-                &qualified_call_path.call_path,
-            )
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn type_decl_opt_to_type_id(
-        &mut self,
-        handler: &Handler,
-        type_decl_opt: Option<TyDecl>,
-        call_path: &CallPath,
-        span: &Span,
-        enforce_type_arguments: EnforceTypeArguments,
-        mod_path: &ModulePath,
-        type_arguments: Option<Vec<TypeArgument>>,
-    ) -> Result<TypeId, ErrorEmitted> {
-        let decl_engine = self.engines.de();
-        let type_engine = self.engines.te();
-        Ok(match type_decl_opt {
-            Some(ty::TyDecl::StructDecl(ty::StructDecl {
-                decl_id: original_id,
-                ..
-            })) => {
-                // get the copy from the declaration engine
-                let mut new_copy = (*decl_engine.get_struct(&original_id)).clone();
-
-                // monomorphize the copy, in place
-                self.monomorphize_with_modpath(
-                    handler,
-                    &mut new_copy,
-                    &mut type_arguments.unwrap_or_default(),
-                    enforce_type_arguments,
-                    span,
-                    mod_path,
-                )?;
-
-                // insert the new copy in the decl engine
-                let new_decl_ref = decl_engine.insert(new_copy);
-
-                // create the type id from the copy
-                type_engine.insert(
-                    self.engines,
-                    TypeInfo::Struct(new_decl_ref.clone()),
-                    new_decl_ref.span().source_id(),
-                )
-            }
-            Some(ty::TyDecl::EnumDecl(ty::EnumDecl {
-                decl_id: original_id,
-                ..
-            })) => {
-                // get the copy from the declaration engine
-                let mut new_copy = (*decl_engine.get_enum(&original_id)).clone();
-
-                // monomorphize the copy, in place
-                self.monomorphize_with_modpath(
-                    handler,
-                    &mut new_copy,
-                    &mut type_arguments.unwrap_or_default(),
-                    enforce_type_arguments,
-                    span,
-                    mod_path,
-                )?;
-
-                // insert the new copy in the decl engine
-                let new_decl_ref = decl_engine.insert(new_copy);
-
-                // create the type id from the copy
-                type_engine.insert(
-                    self.engines,
-                    TypeInfo::Enum(new_decl_ref.clone()),
-                    new_decl_ref.span().source_id(),
-                )
-            }
-            Some(ty::TyDecl::TypeAliasDecl(ty::TypeAliasDecl {
-                decl_id: original_id,
-                ..
-            })) => {
-                let new_copy = decl_engine.get_type_alias(&original_id);
-
-                // TODO: monomorphize the copy, in place, when generic type aliases are
-                // supported
-
-                new_copy.create_type_id(self.engines)
-            }
-            Some(ty::TyDecl::GenericTypeForFunctionScope(ty::GenericTypeForFunctionScope {
-                type_id,
-                ..
-            })) => type_id,
-            Some(ty::TyDecl::TraitTypeDecl(ty::TraitTypeDecl { decl_id })) => {
-                let decl_type = decl_engine.get_type(&decl_id);
-
-                if let Some(ty) = &decl_type.ty {
-                    ty.type_id
-                } else if let Some(implementing_type) = self.self_type() {
-                    type_engine.insert(
-                        self.engines,
-                        TypeInfo::TraitType {
-                            name: decl_type.name.clone(),
-                            trait_type_id: implementing_type,
-                        },
-                        decl_type.name.span().source_id(),
-                    )
-                } else {
-                    return Err(handler.emit_err(CompileError::Internal(
-                        "Self type not provided.",
-                        span.clone(),
-                    )));
-                }
-            }
-            _ => {
-                let err = handler.emit_err(CompileError::UnknownTypeName {
-                    name: call_path.to_string(),
-                    span: call_path.span(),
-                });
-                type_engine.insert(self.engines, TypeInfo::ErrorRecovery(err), None)
-            }
-        })
-    }
-
     /// Given a name and a type (plus a `self_type` to potentially
     /// resolve it), find items matching in the namespace.
     pub(crate) fn find_items_for_type(
@@ -1042,18 +737,19 @@ impl<'a> TypeCheckContext<'a> {
             .get_items_for_type(self.engines, type_id);
 
         // resolve the type
-        let type_id = self
-            .resolve(
-                handler,
-                type_id,
-                &item_name.span(),
-                EnforceTypeArguments::No,
-                None,
-                item_prefix,
-            )
-            .unwrap_or_else(|err| {
-                type_engine.insert(self.engines, TypeInfo::ErrorRecovery(err), None)
-            });
+        let type_id = resolve_type(
+            handler,
+            self.engines(),
+            self.namespace(),
+            item_prefix,
+            type_id,
+            &item_name.span(),
+            EnforceTypeArguments::No,
+            None,
+            self.self_type(),
+            &self.subst_ctx(),
+        )
+        .unwrap_or_else(|err| type_engine.insert(self.engines, TypeInfo::ErrorRecovery(err), None));
 
         // grab the module where the type itself is declared
         let type_module = self.namespace().lookup_submodule_from_absolute_path(
@@ -1124,7 +820,15 @@ impl<'a> TypeCheckContext<'a> {
         let coercion_check = UnifyCheck::coercion(self.engines);
 
         // default numeric types to u64
-        if type_engine.contains_numeric(decl_engine, type_id) {
+        if type_engine.contains_numeric(self.engines, type_id) {
+            // While collecting unification we don't decay numeric and will ignore this error.
+            if self.collecting_unifications {
+                return Err(handler.emit_err(CompileError::MethodNotFound {
+                    method_name: method_name.clone(),
+                    type_name: self.engines.help_out(type_id).to_string(),
+                    span: method_name.span(),
+                }));
+            }
             type_engine.decay_numeric(handler, self.engines, type_id, &method_name.span())?;
         }
 
@@ -1167,10 +871,10 @@ impl<'a> TypeCheckContext<'a> {
                 let mut impl_self_method = None;
                 for method_ref in maybe_method_decl_refs.clone() {
                     let method = decl_engine.get_function(&method_ref);
-                    if let Some(ty::TyDecl::ImplTrait(impl_trait)) =
+                    if let Some(ty::TyDecl::ImplSelfOrTrait(impl_trait)) =
                         method.implementing_type.clone()
                     {
-                        let trait_decl = decl_engine.get_impl_trait(&impl_trait.decl_id);
+                        let trait_decl = decl_engine.get_impl_self_or_trait(&impl_trait.decl_id);
                         let mut skip_insert = false;
                         if let Some(as_trait) = as_trait {
                             if let TypeInfo::Custom {
@@ -1194,11 +898,19 @@ impl<'a> TypeCheckContext<'a> {
                                                 .iter()
                                                 .zip(trait_decl.trait_type_arguments.clone())
                                             {
-                                                let p1_type_id = self.resolve_type_without_self(
-                                                    handler, p1.type_id, &p1.span, None,
+                                                let p1_type_id = self.resolve_type(
+                                                    handler,
+                                                    p1.type_id,
+                                                    &p1.span,
+                                                    EnforceTypeArguments::Yes,
+                                                    None,
                                                 )?;
-                                                let p2_type_id = self.resolve_type_without_self(
-                                                    handler, p2.type_id, &p2.span, None,
+                                                let p2_type_id = self.resolve_type(
+                                                    handler,
+                                                    p2.type_id,
+                                                    &p2.span,
+                                                    EnforceTypeArguments::Yes,
+                                                    None,
                                                 )?;
                                                 if !eq_check.check(p1_type_id, p2_type_id) {
                                                     params_equal = false;
@@ -1355,12 +1067,13 @@ impl<'a> TypeCheckContext<'a> {
         &mut self,
         handler: &Handler,
         src: &ModulePath,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let engines = self.engines;
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .star_import(handler, engines, src, &mod_path)
+            .star_import(handler, engines, src, &mod_path, visibility)
     }
 
     /// Short-hand for performing a [Module::variant_star_import] with `mod_path` as the destination.
@@ -1369,12 +1082,13 @@ impl<'a> TypeCheckContext<'a> {
         handler: &Handler,
         src: &ModulePath,
         enum_name: &Ident,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let engines = self.engines;
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .variant_star_import(handler, engines, src, &mod_path, enum_name)
+            .variant_star_import(handler, engines, src, &mod_path, enum_name, visibility)
     }
 
     /// Short-hand for performing a [Module::self_import] with `mod_path` as the destination.
@@ -1383,12 +1097,13 @@ impl<'a> TypeCheckContext<'a> {
         handler: &Handler,
         src: &ModulePath,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let engines = self.engines;
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .self_import(handler, engines, src, &mod_path, alias)
+            .self_import(handler, engines, src, &mod_path, alias, visibility)
     }
 
     // Import all impls for a struct/enum. Do nothing for other types.
@@ -1396,12 +1111,12 @@ impl<'a> TypeCheckContext<'a> {
         let type_info = engines.te().get(type_id);
 
         let decl_call_path = match &*type_info {
-            TypeInfo::Enum(decl_ref) => {
-                let decl = engines.de().get(decl_ref.id());
+            TypeInfo::Enum(decl_id) => {
+                let decl = engines.de().get(decl_id);
                 decl.call_path.clone()
             }
-            TypeInfo::Struct(decl_ref) => {
-                let decl = engines.de().get(decl_ref.id());
+            TypeInfo::Struct(decl_id) => {
+                let decl = engines.de().get(decl_id);
                 decl.call_path.clone()
             }
             _ => return,
@@ -1419,7 +1134,7 @@ impl<'a> TypeCheckContext<'a> {
             src_mod
                 .current_items()
                 .implemented_traits
-                .filter_by_type_item_import(type_id, engines),
+                .filter_by_type_item_import(type_id, engines, self.code_block_first_pass().into()),
             engines,
         );
 
@@ -1437,12 +1152,13 @@ impl<'a> TypeCheckContext<'a> {
         src: &ModulePath,
         item: &Ident,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let engines = self.engines;
         let mod_path = self.namespace().mod_path.clone();
         self.namespace_mut()
             .root
-            .item_import(handler, engines, src, item, &mod_path, alias)
+            .item_import(handler, engines, src, item, &mod_path, alias, visibility)
     }
 
     /// Short-hand for performing a [Module::variant_import] with `mod_path` as the destination.
@@ -1454,6 +1170,7 @@ impl<'a> TypeCheckContext<'a> {
         enum_name: &Ident,
         variant_name: &Ident,
         alias: Option<Ident>,
+        visibility: Visibility,
     ) -> Result<(), ErrorEmitted> {
         let engines = self.engines;
         let mod_path = self.namespace().mod_path.clone();
@@ -1465,6 +1182,7 @@ impl<'a> TypeCheckContext<'a> {
             variant_name,
             &mod_path,
             alias,
+            visibility,
         )
     }
 
@@ -1537,186 +1255,14 @@ impl<'a> TypeCheckContext<'a> {
             )
     }
 
-    /// Given a `value` of type `T` that is able to be monomorphized and a set
-    /// of `type_arguments`, monomorphize `value` with the `type_arguments`.
-    ///
-    /// When this function is called, it is passed a `T` that is a copy of some
-    /// original declaration for `T` (let's denote the original with `[T]`).
-    /// Because monomorphization happens at application time (e.g. function
-    /// application), we want to be able to modify `value` such that type
-    /// checking the application of `value` affects only `T` and not `[T]`.
-    ///
-    /// So, at a high level, this function does two things. It 1) performs the
-    /// necessary work to refresh the relevant generic types in `T` so that they
-    /// are distinct from the generics of the same name in `[T]`. And it 2)
-    /// applies `type_arguments` (if any are provided) to the type parameters
-    /// of `value`, unifying the types.
-    ///
-    /// There are 4 cases that are handled in this function:
-    ///
-    /// 1. `value` does not have type parameters + `type_arguments` is empty:
-    ///     1a. return ok
-    /// 2. `value` has type parameters + `type_arguments` is empty:
-    ///     2a. if the [EnforceTypeArguments::Yes] variant is provided, then
-    ///         error
-    ///     2b. refresh the generic types with a [TypeSubstMapping]
-    /// 3. `value` does have type parameters + `type_arguments` is nonempty:
-    ///     3a. error
-    /// 4. `value` has type parameters + `type_arguments` is nonempty:
-    ///     4a. check to see that the type parameters and `type_arguments` have
-    ///         the same length
-    ///     4b. for each type argument in `type_arguments`, resolve the type
-    ///     4c. refresh the generic types with a [TypeSubstMapping]
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn monomorphize_with_modpath<T>(
-        &mut self,
-        handler: &Handler,
-        value: &mut T,
-        type_arguments: &mut [TypeArgument],
-        enforce_type_arguments: EnforceTypeArguments,
-        call_site_span: &Span,
-        mod_path: &ModulePath,
-    ) -> Result<(), ErrorEmitted>
-    where
-        T: MonomorphizeHelper + SubstTypes,
-    {
-        let type_mapping = self.prepare_type_subst_map_for_monomorphize(
-            handler,
-            value,
-            type_arguments,
-            enforce_type_arguments,
-            call_site_span,
-            mod_path,
-        )?;
-        value.subst(&type_mapping, self.engines);
-        Ok(())
-    }
-
-    /// Given a `value` of type `T` that is able to be monomorphized and a set
-    /// of `type_arguments`, prepare a `TypeSubstMap` that can be used as an
-    /// input for monomorphization.
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn prepare_type_subst_map_for_monomorphize<T>(
-        &mut self,
-        handler: &Handler,
-        value: &T,
-        type_arguments: &mut [TypeArgument],
-        enforce_type_arguments: EnforceTypeArguments,
-        call_site_span: &Span,
-        mod_path: &ModulePath,
-    ) -> Result<TypeSubstMap, ErrorEmitted>
-    where
-        T: MonomorphizeHelper + SubstTypes,
-    {
-        fn make_type_arity_mismatch_error(
-            name: Ident,
-            span: Span,
-            given: usize,
-            expected: usize,
-        ) -> CompileError {
-            match (expected, given) {
-                (0, 0) => unreachable!(),
-                (_, 0) => CompileError::NeedsTypeArguments { name, span },
-                (0, _) => CompileError::DoesNotTakeTypeArguments { name, span },
-                (_, _) => CompileError::IncorrectNumberOfTypeArguments {
-                    name,
-                    given,
-                    expected,
-                    span,
-                },
-            }
-        }
-
-        match (value.type_parameters().len(), type_arguments.len()) {
-            (0, 0) => Ok(TypeSubstMap::default()),
-            (num_type_params, 0) => {
-                if let EnforceTypeArguments::Yes = enforce_type_arguments {
-                    return Err(handler.emit_err(make_type_arity_mismatch_error(
-                        value.name().clone(),
-                        call_site_span.clone(),
-                        0,
-                        num_type_params,
-                    )));
-                }
-                let type_mapping =
-                    TypeSubstMap::from_type_parameters(self.engines, value.type_parameters());
-                Ok(type_mapping)
-            }
-            (0, num_type_args) => {
-                let type_arguments_span = type_arguments
-                    .iter()
-                    .map(|x| x.span.clone())
-                    .reduce(|s1: Span, s2: Span| Span::join(s1, &s2))
-                    .unwrap_or_else(|| value.name().span());
-                Err(handler.emit_err(make_type_arity_mismatch_error(
-                    value.name().clone(),
-                    type_arguments_span.clone(),
-                    num_type_args,
-                    0,
-                )))
-            }
-            (num_type_params, num_type_args) => {
-                let type_arguments_span = type_arguments
-                    .iter()
-                    .map(|x| x.span.clone())
-                    .reduce(|s1: Span, s2: Span| Span::join(s1, &s2))
-                    .unwrap_or_else(|| value.name().span());
-                // a trait decl is passed the self type parameter and the corresponding argument
-                // but it would be confusing for the user if the error reporting mechanism
-                // reported the number of arguments including the implicit self, hence
-                // we adjust it below
-                let adjust_for_trait_decl = value.has_self_type_param() as usize;
-                let num_type_params = num_type_params - adjust_for_trait_decl;
-                let num_type_args = num_type_args - adjust_for_trait_decl;
-                if num_type_params != num_type_args {
-                    return Err(handler.emit_err(make_type_arity_mismatch_error(
-                        value.name().clone(),
-                        type_arguments_span,
-                        num_type_args,
-                        num_type_params,
-                    )));
-                }
-                for type_argument in type_arguments.iter_mut() {
-                    type_argument.type_id = self
-                        .resolve(
-                            handler,
-                            type_argument.type_id,
-                            &type_argument.span,
-                            enforce_type_arguments,
-                            None,
-                            mod_path,
-                        )
-                        .unwrap_or_else(|err| {
-                            self.engines.te().insert(
-                                self.engines,
-                                TypeInfo::ErrorRecovery(err),
-                                None,
-                            )
-                        });
-                }
-                let type_mapping = TypeSubstMap::from_type_parameters_and_type_arguments(
-                    value
-                        .type_parameters()
-                        .iter()
-                        .map(|type_param| type_param.type_id)
-                        .collect(),
-                    type_arguments
-                        .iter()
-                        .map(|type_arg| type_arg.type_id)
-                        .collect(),
-                );
-                Ok(type_mapping)
-            }
-        }
-    }
-
     pub(crate) fn insert_trait_implementation_for_type(&mut self, type_id: TypeId) {
         let engines = self.engines;
+        let code_block_first_pass = self.code_block_first_pass();
         self.namespace_mut()
             .module_mut(engines)
             .current_items_mut()
             .implemented_traits
-            .insert_for_type(engines, type_id);
+            .insert_for_type(engines, type_id, code_block_first_pass.into());
     }
 
     pub fn check_type_impls_traits(
@@ -1726,7 +1272,7 @@ impl<'a> TypeCheckContext<'a> {
     ) -> bool {
         let handler = Handler::default();
         let engines = self.engines;
-
+        let code_block_first_pass = self.code_block_first_pass();
         self.namespace_mut()
             .module_mut(engines)
             .current_items_mut()
@@ -1738,48 +1284,8 @@ impl<'a> TypeCheckContext<'a> {
                 &Span::dummy(),
                 engines,
                 crate::namespace::TryInsertingTraitImplOnFailure::Yes,
+                code_block_first_pass.into(),
             )
             .is_ok()
     }
 }
-
-pub(crate) trait MonomorphizeHelper {
-    fn name(&self) -> &Ident;
-    fn type_parameters(&self) -> &[TypeParameter];
-    fn has_self_type_param(&self) -> bool;
-}
-
-/// This type is used to denote if, during monomorphization, the compiler
-/// should enforce that type arguments be provided. An example of that
-/// might be this:
-///
-/// ```ignore
-/// struct Point<T> {
-///   x: u64,
-///   y: u64
-/// }
-///
-/// fn add<T>(p1: Point<T>, p2: Point<T>) -> Point<T> {
-///   Point {
-///     x: p1.x + p2.x,
-///     y: p1.y + p2.y
-///   }
-/// }
-/// ```
-///
-/// `EnforceTypeArguments` would require that the type annotations
-/// for `p1` and `p2` contain `<...>`. This is to avoid ambiguous definitions:
-///
-/// ```ignore
-/// fn add(p1: Point, p2: Point) -> Point {
-///   Point {
-///     x: p1.x + p2.x,
-///     y: p1.y + p2.y
-///   }
-/// }
-/// ```
-#[derive(Clone, Copy)]
-pub(crate) enum EnforceTypeArguments {
-    Yes,
-    No,
-}
diff --git a/sway-core/src/semantic_analysis/type_resolve.rs b/sway-core/src/semantic_analysis/type_resolve.rs
new file mode 100644
index 00000000000..f2498364acf
--- /dev/null
+++ b/sway-core/src/semantic_analysis/type_resolve.rs
@@ -0,0 +1,522 @@
+use sway_error::{
+    error::CompileError,
+    handler::{ErrorEmitted, Handler},
+};
+use sway_types::{Ident, Span, Spanned};
+use sway_utils::iter_prefixes;
+
+use crate::{
+    language::{
+        ty::{self, TyTraitItem},
+        CallPath, QualifiedCallPath,
+    },
+    monomorphization::type_decl_opt_to_type_id,
+    namespace::{Module, ModulePath, ResolvedDeclaration, ResolvedTraitImplItem},
+    type_system::SubstTypes,
+    EnforceTypeArguments, Engines, Namespace, SubstTypesContext, TypeId, TypeInfo,
+};
+
+/// Resolve the type of the given [TypeId], replacing any instances of
+/// [TypeInfo::Custom] with either a monomorphized struct, monomorphized
+/// enum, or a reference to a type parameter.
+#[allow(clippy::too_many_arguments)]
+pub fn resolve_type(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &Namespace,
+    mod_path: &ModulePath,
+    type_id: TypeId,
+    span: &Span,
+    enforce_type_arguments: EnforceTypeArguments,
+    type_info_prefix: Option<&ModulePath>,
+    self_type: Option<TypeId>,
+    subst_ctx: &SubstTypesContext,
+) -> Result<TypeId, ErrorEmitted> {
+    let type_engine = engines.te();
+    let module_path = type_info_prefix.unwrap_or(mod_path);
+    let type_id = match (*type_engine.get(type_id)).clone() {
+        TypeInfo::Custom {
+            qualified_call_path,
+            type_arguments,
+            root_type_id,
+        } => {
+            let type_decl_opt = if let Some(root_type_id) = root_type_id {
+                resolve_call_path_and_root_type_id(
+                    handler,
+                    engines,
+                    namespace.module(engines),
+                    root_type_id,
+                    None,
+                    &qualified_call_path.clone().to_call_path(handler)?,
+                    self_type,
+                )
+                .ok()
+            } else {
+                resolve_qualified_call_path(
+                    handler,
+                    engines,
+                    namespace,
+                    module_path,
+                    &qualified_call_path,
+                    self_type,
+                    subst_ctx,
+                )
+                .ok()
+            };
+            type_decl_opt_to_type_id(
+                handler,
+                engines,
+                namespace,
+                type_decl_opt,
+                &qualified_call_path.call_path,
+                span,
+                enforce_type_arguments,
+                mod_path,
+                type_arguments.clone(),
+                self_type,
+                subst_ctx,
+            )?
+        }
+        TypeInfo::Array(mut elem_ty, n) => {
+            elem_ty.type_id = resolve_type(
+                handler,
+                engines,
+                namespace,
+                mod_path,
+                elem_ty.type_id,
+                span,
+                enforce_type_arguments,
+                None,
+                self_type,
+                subst_ctx,
+            )
+            .unwrap_or_else(|err| {
+                engines
+                    .te()
+                    .insert(engines, TypeInfo::ErrorRecovery(err), None)
+            });
+
+            engines.te().insert(
+                engines,
+                TypeInfo::Array(elem_ty.clone(), n.clone()),
+                elem_ty.span.source_id(),
+            )
+        }
+        TypeInfo::Slice(mut elem_ty) => {
+            elem_ty.type_id = resolve_type(
+                handler,
+                engines,
+                namespace,
+                mod_path,
+                elem_ty.type_id,
+                span,
+                enforce_type_arguments,
+                None,
+                self_type,
+                subst_ctx,
+            )
+            .unwrap_or_else(|err| {
+                engines
+                    .te()
+                    .insert(engines, TypeInfo::ErrorRecovery(err), None)
+            });
+
+            engines.te().insert(
+                engines,
+                TypeInfo::Slice(elem_ty.clone()),
+                elem_ty.span.source_id(),
+            )
+        }
+        TypeInfo::Tuple(mut type_arguments) => {
+            for type_argument in type_arguments.iter_mut() {
+                type_argument.type_id = resolve_type(
+                    handler,
+                    engines,
+                    namespace,
+                    mod_path,
+                    type_argument.type_id,
+                    span,
+                    enforce_type_arguments,
+                    None,
+                    self_type,
+                    subst_ctx,
+                )
+                .unwrap_or_else(|err| {
+                    engines
+                        .te()
+                        .insert(engines, TypeInfo::ErrorRecovery(err), None)
+                });
+            }
+
+            engines
+                .te()
+                .insert(engines, TypeInfo::Tuple(type_arguments), span.source_id())
+        }
+        TypeInfo::TraitType {
+            name,
+            trait_type_id,
+        } => {
+            let trait_item_ref = namespace
+                .root
+                .module
+                .current_items()
+                .implemented_traits
+                .get_trait_item_for_type(handler, engines, &name, trait_type_id, None)?;
+
+            if let ResolvedTraitImplItem::Typed(TyTraitItem::Type(type_ref)) = trait_item_ref {
+                let type_decl = engines.de().get_type(type_ref.id());
+                if let Some(ty) = &type_decl.ty {
+                    ty.type_id
+                } else {
+                    type_id
+                }
+            } else {
+                return Err(handler.emit_err(CompileError::Internal(
+                    "Expecting associated type",
+                    trait_item_ref.span(engines),
+                )));
+            }
+        }
+        TypeInfo::Ref {
+            referenced_type: mut ty,
+            to_mutable_value,
+        } => {
+            ty.type_id = resolve_type(
+                handler,
+                engines,
+                namespace,
+                mod_path,
+                ty.type_id,
+                span,
+                enforce_type_arguments,
+                None,
+                self_type,
+                subst_ctx,
+            )
+            .unwrap_or_else(|err| {
+                engines
+                    .te()
+                    .insert(engines, TypeInfo::ErrorRecovery(err), None)
+            });
+
+            engines.te().insert(
+                engines,
+                TypeInfo::Ref {
+                    to_mutable_value,
+                    referenced_type: ty.clone(),
+                },
+                None,
+            )
+        }
+        _ => type_id,
+    };
+
+    let mut type_id = type_id;
+    type_id.subst(subst_ctx);
+
+    Ok(type_id)
+}
+
+pub fn resolve_qualified_call_path(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &Namespace,
+    mod_path: &ModulePath,
+    qualified_call_path: &QualifiedCallPath,
+    self_type: Option<TypeId>,
+    subst_ctx: &SubstTypesContext,
+) -> Result<ResolvedDeclaration, ErrorEmitted> {
+    let type_engine = engines.te();
+    if let Some(qualified_path_root) = qualified_call_path.clone().qualified_path_root {
+        let root_type_id = match &&*type_engine.get(qualified_path_root.ty.type_id) {
+            TypeInfo::Custom {
+                qualified_call_path,
+                type_arguments,
+                ..
+            } => {
+                let type_decl = resolve_call_path(
+                    handler,
+                    engines,
+                    namespace,
+                    mod_path,
+                    &qualified_call_path.clone().to_call_path(handler)?,
+                    self_type,
+                )?;
+                type_decl_opt_to_type_id(
+                    handler,
+                    engines,
+                    namespace,
+                    Some(type_decl),
+                    &qualified_call_path.call_path,
+                    &qualified_path_root.ty.span(),
+                    EnforceTypeArguments::No,
+                    mod_path,
+                    type_arguments.clone(),
+                    self_type,
+                    subst_ctx,
+                )?
+            }
+            _ => qualified_path_root.ty.type_id,
+        };
+
+        let as_trait_opt = match &&*type_engine.get(qualified_path_root.as_trait) {
+            TypeInfo::Custom {
+                qualified_call_path: call_path,
+                ..
+            } => Some(
+                call_path
+                    .clone()
+                    .to_call_path(handler)?
+                    .to_fullpath(engines, namespace),
+            ),
+            _ => None,
+        };
+
+        resolve_call_path_and_root_type_id(
+            handler,
+            engines,
+            &namespace.root.module,
+            root_type_id,
+            as_trait_opt,
+            &qualified_call_path.call_path,
+            self_type,
+        )
+    } else {
+        resolve_call_path(
+            handler,
+            engines,
+            namespace,
+            mod_path,
+            &qualified_call_path.call_path,
+            self_type,
+        )
+    }
+}
+
+/// Resolve a symbol that is potentially prefixed with some path, e.g. `foo::bar::symbol`.
+///
+/// This will concatenate the `mod_path` with the `call_path`'s prefixes and
+/// then calling `resolve_symbol` with the resulting path and call_path's suffix.
+///
+/// The `mod_path` is significant here as we assume the resolution is done within the
+/// context of the module pointed to by `mod_path` and will only check the call path prefixes
+/// and the symbol's own visibility.
+pub fn resolve_call_path(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &Namespace,
+    mod_path: &ModulePath,
+    call_path: &CallPath,
+    self_type: Option<TypeId>,
+) -> Result<ResolvedDeclaration, ErrorEmitted> {
+    let (decl, mod_path) = namespace
+        .root
+        .resolve_call_path_and_mod_path(handler, engines, mod_path, call_path, self_type)?;
+
+    // In case there is no mod path we don't need to check visibility
+    if mod_path.is_empty() {
+        return Ok(decl);
+    }
+
+    // In case there are no prefixes we don't need to check visibility
+    if call_path.prefixes.is_empty() {
+        return Ok(decl);
+    }
+
+    // check the visibility of the call path elements
+    // we don't check the first prefix because direct children are always accessible
+    for prefix in iter_prefixes(&call_path.prefixes).skip(1) {
+        let module = namespace.lookup_submodule_from_absolute_path(handler, engines, prefix)?;
+        if module.visibility().is_private() {
+            let prefix_last = prefix[prefix.len() - 1].clone();
+            handler.emit_err(CompileError::ImportPrivateModule {
+                span: prefix_last.span(),
+                name: prefix_last,
+            });
+        }
+    }
+
+    // check the visibility of the symbol itself
+    if !decl.visibility(engines).is_public() {
+        handler.emit_err(CompileError::ImportPrivateSymbol {
+            name: call_path.suffix.clone(),
+            span: call_path.suffix.span(),
+        });
+    }
+
+    Ok(decl)
+}
+
+pub fn decl_to_type_info(
+    handler: &Handler,
+    engines: &Engines,
+    symbol: &Ident,
+    decl: ResolvedDeclaration,
+) -> Result<TypeInfo, ErrorEmitted> {
+    match decl {
+        ResolvedDeclaration::Parsed(_decl) => todo!(),
+        ResolvedDeclaration::Typed(decl) => Ok(match decl.clone() {
+            ty::TyDecl::StructDecl(struct_ty_decl) => TypeInfo::Struct(struct_ty_decl.decl_id),
+            ty::TyDecl::EnumDecl(enum_ty_decl) => TypeInfo::Enum(enum_ty_decl.decl_id),
+            ty::TyDecl::TraitTypeDecl(type_decl) => {
+                let type_decl = engines.de().get_type(&type_decl.decl_id);
+                if type_decl.ty.is_none() {
+                    return Err(handler.emit_err(CompileError::Internal(
+                        "Trait type declaration has no type",
+                        symbol.span(),
+                    )));
+                }
+                (*engines.te().get(type_decl.ty.clone().unwrap().type_id)).clone()
+            }
+            _ => {
+                return Err(handler.emit_err(CompileError::SymbolNotFound {
+                    name: symbol.clone(),
+                    span: symbol.span(),
+                }))
+            }
+        }),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn resolve_associated_item_from_type_id(
+    handler: &Handler,
+    engines: &Engines,
+    module: &Module,
+    symbol: &Ident,
+    type_id: TypeId,
+    as_trait: Option<CallPath>,
+    self_type: Option<TypeId>,
+) -> Result<ResolvedDeclaration, ErrorEmitted> {
+    let type_id = if engines.te().get(type_id).is_self_type() {
+        if let Some(self_type) = self_type {
+            self_type
+        } else {
+            return Err(handler.emit_err(CompileError::Internal(
+                "Self type not provided.",
+                symbol.span(),
+            )));
+        }
+    } else {
+        type_id
+    };
+    let item_ref = module
+        .current_items()
+        .implemented_traits
+        .get_trait_item_for_type(handler, engines, symbol, type_id, as_trait)?;
+    match item_ref {
+        ResolvedTraitImplItem::Parsed(_item) => todo!(),
+        ResolvedTraitImplItem::Typed(item) => match item {
+            TyTraitItem::Fn(fn_ref) => Ok(ResolvedDeclaration::Typed(fn_ref.into())),
+            TyTraitItem::Constant(const_ref) => Ok(ResolvedDeclaration::Typed(const_ref.into())),
+            TyTraitItem::Type(type_ref) => Ok(ResolvedDeclaration::Typed(type_ref.into())),
+        },
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn resolve_associated_type(
+    handler: &Handler,
+    engines: &Engines,
+    module: &Module,
+    symbol: &Ident,
+    decl: ResolvedDeclaration,
+    as_trait: Option<CallPath>,
+    self_type: Option<TypeId>,
+) -> Result<ResolvedDeclaration, ErrorEmitted> {
+    let type_info = decl_to_type_info(handler, engines, symbol, decl)?;
+    let type_id = engines
+        .te()
+        .insert(engines, type_info, symbol.span().source_id());
+
+    resolve_associated_item_from_type_id(
+        handler, engines, module, symbol, type_id, as_trait, self_type,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn resolve_associated_item(
+    handler: &Handler,
+    engines: &Engines,
+    module: &Module,
+    symbol: &Ident,
+    decl: ResolvedDeclaration,
+    as_trait: Option<CallPath>,
+    self_type: Option<TypeId>,
+) -> Result<ResolvedDeclaration, ErrorEmitted> {
+    let type_info = decl_to_type_info(handler, engines, symbol, decl)?;
+    let type_id = engines
+        .te()
+        .insert(engines, type_info, symbol.span().source_id());
+
+    resolve_associated_item_from_type_id(
+        handler, engines, module, symbol, type_id, as_trait, self_type,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn resolve_call_path_and_root_type_id(
+    handler: &Handler,
+    engines: &Engines,
+    module: &Module,
+    root_type_id: TypeId,
+    mut as_trait: Option<CallPath>,
+    call_path: &CallPath,
+    self_type: Option<TypeId>,
+) -> Result<ResolvedDeclaration, ErrorEmitted> {
+    // This block tries to resolve associated types
+    let mut decl_opt = None;
+    let mut type_id_opt = Some(root_type_id);
+    for ident in call_path.prefixes.iter() {
+        if let Some(type_id) = type_id_opt {
+            type_id_opt = None;
+            decl_opt = Some(resolve_associated_item_from_type_id(
+                handler,
+                engines,
+                module,
+                ident,
+                type_id,
+                as_trait.clone(),
+                self_type,
+            )?);
+            as_trait = None;
+        } else if let Some(decl) = decl_opt {
+            decl_opt = Some(resolve_associated_type(
+                handler,
+                engines,
+                module,
+                ident,
+                decl,
+                as_trait.clone(),
+                self_type,
+            )?);
+            as_trait = None;
+        }
+    }
+    if let Some(type_id) = type_id_opt {
+        let decl = resolve_associated_item_from_type_id(
+            handler,
+            engines,
+            module,
+            &call_path.suffix,
+            type_id,
+            as_trait,
+            self_type,
+        )?;
+        return Ok(decl);
+    }
+    if let Some(decl) = decl_opt {
+        let decl = resolve_associated_item(
+            handler,
+            engines,
+            module,
+            &call_path.suffix,
+            decl,
+            as_trait,
+            self_type,
+        )?;
+        Ok(decl)
+    } else {
+        Err(handler.emit_err(CompileError::Internal("Unexpected error", call_path.span())))
+    }
+}
diff --git a/sway-core/src/transform/to_parsed_lang/context.rs b/sway-core/src/transform/to_parsed_lang/context.rs
index 4358abec4f0..f450eb5257f 100644
--- a/sway-core/src/transform/to_parsed_lang/context.rs
+++ b/sway-core/src/transform/to_parsed_lang/context.rs
@@ -1,4 +1,8 @@
-use crate::{build_config::ExperimentalFlags, language::parsed::TreeType, BuildTarget};
+use crate::{
+    build_config::ExperimentalFlags,
+    language::parsed::{Declaration, TreeType},
+    BuildTarget,
+};
 
 pub struct Context {
     pub experimental: ExperimentalFlags,
@@ -16,11 +20,17 @@ pub struct Context {
     /// that store values matched in match expressions.
     match_expression_matched_value_unique_suffix: usize,
 
+    /// Unique suffix used to generate unique names for for loops.
+    for_unique_suffix: usize,
+
     /// The build target.
     build_target: BuildTarget,
 
     /// The program type.
     program_type: Option<TreeType>,
+
+    /// Keeps track of the implementing type as we convert the tree.
+    pub(crate) implementing_type: Option<Declaration>,
 }
 
 impl Context {
@@ -33,7 +43,9 @@ impl Context {
             destructured_struct_unique_suffix: std::default::Default::default(),
             destructured_tuple_unique_suffix: std::default::Default::default(),
             match_expression_matched_value_unique_suffix: std::default::Default::default(),
+            for_unique_suffix: std::default::Default::default(),
             program_type: std::default::Default::default(),
+            implementing_type: None,
         }
     }
 
@@ -66,6 +78,12 @@ impl Context {
         self.match_expression_matched_value_unique_suffix
     }
 
+    /// Returns a unique suffix used to generate a unique name for a destructured struct.
+    pub fn next_for_unique_suffix(&mut self) -> usize {
+        self.for_unique_suffix += 1;
+        self.for_unique_suffix
+    }
+
     /// Returns the build target.
     pub fn build_target(&self) -> BuildTarget {
         self.build_target
diff --git a/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs b/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs
index 8d24ef5760d..b48cce083eb 100644
--- a/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs
+++ b/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs
@@ -34,11 +34,12 @@ use sway_types::{
         ALLOW_ATTRIBUTE_NAME, CFG_ATTRIBUTE_NAME, CFG_EXPERIMENTAL_NEW_ENCODING,
         CFG_PROGRAM_TYPE_ARG_NAME, CFG_TARGET_ARG_NAME, DEPRECATED_ATTRIBUTE_NAME,
         DOC_ATTRIBUTE_NAME, DOC_COMMENT_ATTRIBUTE_NAME, FALLBACK_ATTRIBUTE_NAME,
-        INLINE_ATTRIBUTE_NAME, NAMESPACE_ATTRIBUTE_NAME, PAYABLE_ATTRIBUTE_NAME,
-        STORAGE_PURITY_ATTRIBUTE_NAME, STORAGE_PURITY_READ_NAME, STORAGE_PURITY_WRITE_NAME,
-        TEST_ATTRIBUTE_NAME, VALID_ATTRIBUTE_NAMES,
+        INLINE_ATTRIBUTE_NAME, PAYABLE_ATTRIBUTE_NAME, STORAGE_PURITY_ATTRIBUTE_NAME,
+        STORAGE_PURITY_READ_NAME, STORAGE_PURITY_WRITE_NAME, TEST_ATTRIBUTE_NAME,
+        VALID_ATTRIBUTE_NAMES,
     },
     integer_bits::IntegerBits,
+    BaseIdent,
 };
 use sway_types::{Ident, Span, Spanned};
 
@@ -173,9 +174,17 @@ pub fn item_to_ast_nodes(
             .into_iter()
             .map(AstNodeContent::UseStatement)
             .collect(),
-        ItemKind::Struct(item_struct) => decl(Declaration::StructDeclaration(
-            item_struct_to_struct_declaration(context, handler, engines, item_struct, attributes)?,
-        )),
+        ItemKind::Struct(item_struct) => {
+            let struct_decl = Declaration::StructDeclaration(item_struct_to_struct_declaration(
+                context,
+                handler,
+                engines,
+                item_struct,
+                attributes,
+            )?);
+            context.implementing_type = Some(struct_decl.clone());
+            decl(struct_decl)
+        }
         ItemKind::Enum(item_enum) => decl(Declaration::EnumDeclaration(
             item_enum_to_enum_declaration(context, handler, engines, item_enum, attributes)?,
         )),
@@ -202,15 +211,25 @@ pub fn item_to_ast_nodes(
                 function_declaration_decl_id,
             ))
         }
-        ItemKind::Trait(item_trait) => decl(Declaration::TraitDeclaration(
-            item_trait_to_trait_declaration(context, handler, engines, item_trait, attributes)?,
-        )),
-        ItemKind::Impl(item_impl) => decl(item_impl_to_declaration(
-            context, handler, engines, item_impl,
-        )?),
-        ItemKind::Abi(item_abi) => decl(Declaration::AbiDeclaration(item_abi_to_abi_declaration(
-            context, handler, engines, item_abi, attributes,
-        )?)),
+        ItemKind::Trait(item_trait) => {
+            let trait_decl = Declaration::TraitDeclaration(item_trait_to_trait_declaration(
+                context, handler, engines, item_trait, attributes,
+            )?);
+            context.implementing_type = Some(trait_decl.clone());
+            decl(trait_decl)
+        }
+        ItemKind::Impl(item_impl) => {
+            let impl_decl = item_impl_to_declaration(context, handler, engines, item_impl)?;
+            context.implementing_type = Some(impl_decl.clone());
+            decl(impl_decl)
+        }
+        ItemKind::Abi(item_abi) => {
+            let abi_decl = Declaration::AbiDeclaration(item_abi_to_abi_declaration(
+                context, handler, engines, item_abi, attributes,
+            )?);
+            context.implementing_type = Some(abi_decl.clone());
+            decl(abi_decl)
+        }
         ItemKind::Const(item_const) => decl(Declaration::ConstantDeclaration({
             item_const_to_constant_declaration(
                 context, handler, engines, item_const, attributes, true,
@@ -265,13 +284,6 @@ fn item_use_to_use_statements(
     handler: &Handler,
     item_use: ItemUse,
 ) -> Result<Vec<UseStatement>, ErrorEmitted> {
-    if let Some(pub_token) = item_use.visibility {
-        let error = ConvertParseTreeError::PubUseNotSupported {
-            span: pub_token.span(),
-        };
-        return Err(handler.emit_err(error.into()));
-    }
-
     let mut ret = Vec::new();
     let mut prefix = Vec::new();
     let item_span = item_use.span();
@@ -279,6 +291,7 @@ fn item_use_to_use_statements(
     use_tree_to_use_statements(
         item_use.tree,
         item_use.root_import.is_some(),
+        pub_token_opt_to_visibility(item_use.visibility),
         &mut prefix,
         &mut ret,
         item_span,
@@ -302,6 +315,7 @@ fn item_use_to_use_statements(
 fn use_tree_to_use_statements(
     use_tree: UseTree,
     is_absolute: bool,
+    reexport: Visibility,
     path: &mut Vec<Ident>,
     ret: &mut Vec<UseStatement>,
     item_span: Span,
@@ -309,7 +323,14 @@ fn use_tree_to_use_statements(
     match use_tree {
         UseTree::Group { imports } => {
             for use_tree in imports.into_inner() {
-                use_tree_to_use_statements(use_tree, is_absolute, path, ret, item_span.clone());
+                use_tree_to_use_statements(
+                    use_tree,
+                    is_absolute,
+                    reexport,
+                    path,
+                    ret,
+                    item_span.clone(),
+                );
             }
         }
         UseTree::Name { name } => {
@@ -323,6 +344,7 @@ fn use_tree_to_use_statements(
                 span: item_span,
                 import_type,
                 is_absolute,
+                reexport,
                 alias: None,
             });
         }
@@ -337,6 +359,7 @@ fn use_tree_to_use_statements(
                 span: item_span,
                 import_type,
                 is_absolute,
+                reexport,
                 alias: Some(alias),
             });
         }
@@ -346,12 +369,13 @@ fn use_tree_to_use_statements(
                 span: item_span,
                 import_type: ImportType::Star,
                 is_absolute,
+                reexport,
                 alias: None,
             });
         }
         UseTree::Path { prefix, suffix, .. } => {
             path.push(prefix);
-            use_tree_to_use_statements(*suffix, is_absolute, path, ret, item_span);
+            use_tree_to_use_statements(*suffix, is_absolute, reexport, path, ret, item_span);
             path.pop().unwrap();
         }
         UseTree::Error { .. } => {
@@ -539,6 +563,7 @@ pub fn item_fn_to_function_declaration(
     };
 
     let kind = override_kind.unwrap_or(kind);
+    let implementing_type = context.implementing_type.clone();
 
     let fn_decl = FunctionDeclaration {
         purity: get_attributed_purity(context, handler, &attributes)?,
@@ -572,6 +597,7 @@ pub fn item_fn_to_function_declaration(
             .transpose()?
             .unwrap_or(vec![]),
         kind,
+        implementing_type,
     };
     let decl_id = engines.pe().insert(fn_decl);
     Ok(decl_id)
@@ -767,29 +793,39 @@ pub fn item_impl_to_declaration(
         Some((path_type, _)) => {
             let (trait_name, trait_type_arguments) =
                 path_type_to_call_path_and_type_arguments(context, handler, engines, path_type)?;
-            let impl_trait = ImplTrait {
+            let impl_trait = ImplSelfOrTrait {
+                is_self: false,
                 impl_type_parameters,
                 trait_name: trait_name.to_call_path(handler)?,
                 trait_type_arguments,
+                trait_decl_ref: None,
                 implementing_for,
                 items,
                 block_span,
             };
             let impl_trait = engines.pe().insert(impl_trait);
-            Ok(Declaration::ImplTrait(impl_trait))
+            Ok(Declaration::ImplSelfOrTrait(impl_trait))
         }
         None => match &*engines.te().get(implementing_for.type_id) {
             TypeInfo::Contract => Err(handler
                 .emit_err(ConvertParseTreeError::SelfImplForContract { span: block_span }.into())),
             _ => {
-                let impl_self = ImplSelf {
+                let impl_self = ImplSelfOrTrait {
+                    is_self: true,
+                    trait_name: CallPath {
+                        is_absolute: false,
+                        prefixes: vec![],
+                        suffix: BaseIdent::dummy(),
+                    },
+                    trait_decl_ref: None,
+                    trait_type_arguments: vec![],
                     implementing_for,
                     impl_type_parameters,
                     items,
                     block_span,
                 };
                 let impl_self = engines.pe().insert(impl_self);
-                Ok(Declaration::ImplSelf(impl_self))
+                Ok(Declaration::ImplSelfOrTrait(impl_self))
             }
         },
     }
@@ -965,7 +1001,6 @@ pub(crate) fn item_const_to_constant_declaration(
         type_ascription,
         value: expr,
         visibility: pub_token_opt_to_visibility(item_const.visibility),
-        is_configurable: false,
         attributes,
         span,
     };
@@ -1085,6 +1120,7 @@ fn item_configurable_to_configurable_declarations(
         });
     }
 
+    let item_configurable_keyword_span = item_configurable.configurable_token.span();
     let declarations: Vec<ParsedDeclId<ConfigurableDeclaration>> = item_configurable
         .fields
         .into_inner()
@@ -1101,6 +1137,7 @@ fn item_configurable_to_configurable_declarations(
                 engines,
                 configurable_field.value,
                 attributes,
+                item_configurable_keyword_span.clone(),
             )?))
         })
         .filter_map_ok(|decl| decl)
@@ -1746,6 +1783,7 @@ fn struct_path_and_fields_to_struct_expression(
     };
     Ok(Box::new(StructExpression {
         call_path_binding,
+        resolved_call_path_binding: None,
         fields,
     }))
 }
@@ -1894,6 +1932,7 @@ fn expr_func_app_to_expression_kind(
                                     type_arguments: TypeArgs::Regular(type_arguments),
                                     span: span.clone(),
                                 },
+                                resolved_call_path_binding: None,
                                 arguments,
                             },
                         )),
@@ -2571,6 +2610,7 @@ fn configurable_field_to_configurable_declaration(
     engines: &Engines,
     configurable_field: sway_ast::ConfigurableField,
     attributes: AttributesMap,
+    item_configurable_keyword_span: Span,
 ) -> Result<ParsedDeclId<ConfigurableDeclaration>, ErrorEmitted> {
     let span = configurable_field.name.span();
 
@@ -2589,6 +2629,7 @@ fn configurable_field_to_configurable_declaration(
                     type_arguments: TypeArgs::Regular(vec![type_ascription.clone()]),
                     span: span.clone(),
                 },
+                resolved_call_path_binding: None,
                 arguments: vec![value],
             }));
         Expression {
@@ -2606,6 +2647,7 @@ fn configurable_field_to_configurable_declaration(
         visibility: Visibility::Public,
         attributes,
         span: span.clone(),
+        block_keyword_span: item_configurable_keyword_span,
     };
     Ok(engines.pe().insert(config_decl))
 }
@@ -3067,13 +3109,19 @@ fn for_expr_to_expression(
     //        let value = value_opt.unwrap();
     //        code_block
     //    }
-    let value_opt_ident = Ident::new_no_span("__for_value_opt".into());
+    let value_opt_ident = Ident::new_no_span(format!(
+        "__for_value_opt_{}",
+        context.next_for_unique_suffix()
+    ));
     let value_opt_expr = Expression {
         kind: ExpressionKind::Variable(value_opt_ident.clone()),
         span: Span::dummy(),
     };
 
-    let iterable_ident = Ident::new_no_span("__for_iterable".into());
+    let iterable_ident = Ident::new_no_span(format!(
+        "__for_iterable_{}",
+        context.next_for_unique_suffix()
+    ));
     let iterable_expr = Expression {
         kind: ExpressionKind::Variable(iterable_ident.clone()),
         span: Span::dummy(),
@@ -3648,6 +3696,7 @@ fn asm_block_to_asm_expression(
     let whole_block_span = asm_block.span();
     let asm_block_contents = asm_block.contents.into_inner();
     let (returns, return_type) = match asm_block_contents.final_expr_opt {
+        // If the return register is specified.
         Some(asm_final_expr) => {
             let asm_register = AsmRegister {
                 name: asm_final_expr.register.as_str().to_owned(),
@@ -3655,10 +3704,12 @@ fn asm_block_to_asm_expression(
             let returns = Some((asm_register, asm_final_expr.register.span()));
             let return_type = match asm_final_expr.ty_opt {
                 Some((_colon_token, ty)) => ty_to_type_info(context, handler, engines, ty)?,
+                // If the return type is not specified, the ASM block returns `u64` as the default.
                 None => TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
             };
             (returns, return_type)
         }
+        // If the return register is not specified, the return type is unit, `()`.
         None => (None, TypeInfo::Tuple(Vec::new())),
     };
     let registers = {
@@ -3755,7 +3806,11 @@ fn statement_let_to_ast_nodes_unfold(
                     mutable,
                     name,
                 } => (reference, mutable, name),
-                Pattern::Wildcard { .. } => (None, None, Ident::new_no_span("_".into())),
+                Pattern::Wildcard { underscore_token } => (
+                    None,
+                    None,
+                    Ident::new_with_override("_".to_string(), underscore_token.span()),
+                ),
                 Pattern::AmbiguousSingleIdent(ident) => (None, None, ident),
                 _ => unreachable!(),
             };
@@ -3900,7 +3955,7 @@ fn statement_let_to_ast_nodes_unfold(
             let tuple_name =
                 generate_tuple_var_name(context.next_destructured_tuple_unique_suffix());
 
-            let tuple_name = Ident::new_with_override(tuple_name, span.clone());
+            let tuple_name = Ident::new_with_override(tuple_name, pat_tuple.span().clone());
 
             // Acript a second declaration to a tuple of placeholders to check that the tuple
             // is properly sized to the pattern
@@ -3912,13 +3967,16 @@ fn statement_let_to_ast_nodes_unfold(
                             .clone()
                             .into_inner()
                             .into_iter()
-                            .map(|_| {
+                            .map(|pat| {
                                 let initial_type_id =
                                     engines.te().insert(engines, TypeInfo::Unknown, None);
                                 let dummy_type_param = TypeParameter {
                                     type_id: initial_type_id,
                                     initial_type_id,
-                                    name_ident: Ident::new_with_override("_".into(), span.clone()),
+                                    name_ident: Ident::new_with_override(
+                                        "_".into(),
+                                        pat.span().clone(),
+                                    ),
                                     trait_constraints: vec![],
                                     trait_constraints_span: Span::dummy(),
                                     is_from_parent: false,
@@ -4680,13 +4738,6 @@ fn item_attrs_to_map(
         let attrs = attr_decl.attribute.get().into_iter();
         for attr in attrs {
             let name = attr.name.as_str();
-            if name == NAMESPACE_ATTRIBUTE_NAME {
-                handler.emit_warn(CompileWarning {
-                    span: attr_decl.span().clone(),
-                    warning_content: Warning::NamespaceAttributeDeprecated,
-                });
-                continue;
-            }
             if !VALID_ATTRIBUTE_NAMES.contains(&name) {
                 handler.emit_warn(CompileWarning {
                     span: attr_decl.span().clone(),
@@ -4891,8 +4942,13 @@ pub fn cfg_eval(
                         }
                     },
                     _ => {
-                        // Already checked with `AttributeKind::expected_args_*`
-                        unreachable!("cfg attribute should only have the `target` or the `program_type` argument");
+                        return Err(handler.emit_err(
+                            ConvertParseTreeError::InvalidCfgArg {
+                                span: arg.span(),
+                                value: arg.name.as_str().to_string(),
+                            }
+                            .into(),
+                        ));
                     }
                 }
             }
diff --git a/sway-core/src/type_system/ast_elements/binding.rs b/sway-core/src/type_system/ast_elements/binding.rs
index 2a9dd11fc7d..9a4c7c1dd43 100644
--- a/sway-core/src/type_system/ast_elements/binding.rs
+++ b/sway-core/src/type_system/ast_elements/binding.rs
@@ -3,12 +3,20 @@ use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::{Span, Spanned};
 
 use crate::{
-    decl_engine::{DeclEngineInsert, DeclId, DeclRef},
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineGetParsedDeclId, DeclEngineInsert, DeclId, DeclRef,
+    },
     engine_threading::{EqWithEngines, PartialEqWithEngines, PartialEqWithEnginesContext},
-    language::{ty, CallPath, QualifiedCallPath},
-    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
+    language::{
+        parsed::{FunctionDeclaration, StructDeclaration},
+        ty, CallPath, QualifiedCallPath,
+    },
+    semantic_analysis::{
+        symbol_resolve::ResolveSymbols, symbol_resolve_context::SymbolResolveContext,
+        TypeCheckContext,
+    },
     type_system::priv_prelude::*,
-    Ident,
+    EnforceTypeArguments, Ident,
 };
 
 /// A `TypeBinding` is the result of using turbofish to bind types to
@@ -184,6 +192,17 @@ impl<T> TypeBinding<T> {
             span: self.span,
         }
     }
+
+    pub(crate) fn resolve_symbols(&mut self, handler: &Handler, mut ctx: SymbolResolveContext<'_>) {
+        match self.type_arguments {
+            TypeArgs::Regular(ref mut args) => args
+                .iter_mut()
+                .for_each(|arg| arg.resolve_symbols(handler, ctx.by_ref())),
+            TypeArgs::Prefix(ref mut args) => args
+                .iter_mut()
+                .for_each(|arg| arg.resolve_symbols(handler, ctx.by_ref())),
+        }
+    }
 }
 
 impl TypeBinding<CallPath<(TypeInfo, Ident)>> {
@@ -249,6 +268,32 @@ pub(crate) trait TypeCheckTypeBinding<T> {
     ) -> Result<(DeclRef<DeclId<T>>, Option<TypeId>, Option<ty::TyDecl>), ErrorEmitted>;
 }
 
+#[allow(clippy::type_complexity)]
+pub trait SymbolResolveTypeBinding<T> {
+    fn resolve_symbol(
+        &mut self,
+        handler: &Handler,
+        ctx: SymbolResolveContext,
+    ) -> Result<ParsedDeclId<T>, ErrorEmitted>;
+}
+
+impl SymbolResolveTypeBinding<FunctionDeclaration> for TypeBinding<CallPath> {
+    fn resolve_symbol(
+        &mut self,
+        handler: &Handler,
+        ctx: SymbolResolveContext,
+    ) -> Result<ParsedDeclId<FunctionDeclaration>, ErrorEmitted> {
+        let engines = ctx.engines();
+        // Grab the declaration.
+        let unknown_decl = ctx.resolve_call_path_with_visibility_check(handler, &self.inner)?;
+        // Check to see if this is a function declaration.
+        let fn_decl = unknown_decl
+            .resolve_parsed(engines.de())
+            .to_fn_ref(handler, engines)?;
+        Ok(fn_decl)
+    }
+}
+
 impl TypeCheckTypeBinding<ty::TyFunctionDecl> for TypeBinding<CallPath> {
     fn type_check(
         &mut self,
@@ -266,7 +311,9 @@ impl TypeCheckTypeBinding<ty::TyFunctionDecl> for TypeBinding<CallPath> {
         let decl_engine = ctx.engines.de();
         let engines = ctx.engines();
         // Grab the declaration.
-        let unknown_decl = ctx.resolve_call_path_with_visibility_check(handler, &self.inner)?;
+        let unknown_decl = ctx
+            .resolve_call_path_with_visibility_check(handler, &self.inner)?
+            .expect_typed();
         // Check to see if this is a fn declaration.
         let fn_ref = unknown_decl.to_fn_ref(handler, ctx.engines())?;
         // Get a new copy from the declaration engine.
@@ -299,15 +346,34 @@ impl TypeCheckTypeBinding<ty::TyFunctionDecl> for TypeBinding<CallPath> {
             }
         }
         // Insert the new copy into the declaration engine.
-        let new_fn_ref = ctx
-            .engines
-            .de()
-            .insert(new_copy)
+        let new_fn_ref = decl_engine
+            .insert(
+                new_copy,
+                decl_engine.get_parsed_decl_id(fn_ref.id()).as_ref(),
+            )
             .with_parent(ctx.engines.de(), fn_ref.id().into());
         Ok((new_fn_ref, None, None))
     }
 }
 
+impl SymbolResolveTypeBinding<StructDeclaration> for TypeBinding<CallPath> {
+    fn resolve_symbol(
+        &mut self,
+        handler: &Handler,
+        ctx: SymbolResolveContext,
+    ) -> Result<ParsedDeclId<StructDeclaration>, ErrorEmitted> {
+        let engines = ctx.engines();
+        // Grab the declaration.
+        let unknown_decl = ctx.resolve_call_path_with_visibility_check(handler, &self.inner)?;
+
+        // Check to see if this is a struct declaration.
+        let struct_decl = unknown_decl.to_struct_decl(handler, engines)?;
+        struct_decl
+            .resolve_parsed(engines.de())
+            .to_struct_decl(handler, engines)
+    }
+}
+
 impl TypeCheckTypeBinding<ty::TyStructDecl> for TypeBinding<CallPath> {
     fn type_check(
         &mut self,
@@ -325,11 +391,13 @@ impl TypeCheckTypeBinding<ty::TyStructDecl> for TypeBinding<CallPath> {
         let decl_engine = ctx.engines.de();
         let engines = ctx.engines();
         // Grab the declaration.
-        let unknown_decl = ctx.resolve_call_path_with_visibility_check(handler, &self.inner)?;
+        let unknown_decl = ctx
+            .resolve_call_path_with_visibility_check(handler, &self.inner)?
+            .expect_typed();
         // Check to see if this is a struct declaration.
-        let struct_ref = unknown_decl.to_struct_ref(handler, engines)?;
+        let struct_id = unknown_decl.to_struct_decl(handler, engines)?;
         // Get a new copy from the declaration engine.
-        let mut new_copy = (*decl_engine.get_struct(struct_ref.id())).clone();
+        let mut new_copy = (*decl_engine.get_struct(&struct_id)).clone();
         // Monomorphize the copy, in place.
         ctx.monomorphize(
             handler,
@@ -339,10 +407,13 @@ impl TypeCheckTypeBinding<ty::TyStructDecl> for TypeBinding<CallPath> {
             &self.span,
         )?;
         // Insert the new copy into the declaration engine.
-        let new_struct_ref = ctx.engines.de().insert(new_copy);
+        let new_struct_ref = decl_engine.insert(
+            new_copy,
+            decl_engine.get_parsed_decl_id(&struct_id).as_ref(),
+        );
         let type_id = type_engine.insert(
             engines,
-            TypeInfo::Struct(new_struct_ref.clone()),
+            TypeInfo::Struct(*new_struct_ref.id()),
             new_struct_ref.span().source_id(),
         );
         Ok((new_struct_ref, Some(type_id), None))
@@ -366,21 +437,22 @@ impl TypeCheckTypeBinding<ty::TyEnumDecl> for TypeBinding<CallPath> {
         let decl_engine = ctx.engines.de();
         let engines = ctx.engines();
         // Grab the declaration.
-        let unknown_decl = ctx.resolve_call_path_with_visibility_check(handler, &self.inner)?;
+        let unknown_decl = ctx
+            .resolve_call_path_with_visibility_check(handler, &self.inner)?
+            .expect_typed();
 
         // Get a new copy from the declaration engine.
-        let mut new_copy = if let ty::TyDecl::EnumVariantDecl(ty::EnumVariantDecl {
-            enum_ref,
-            ..
-        }) = &unknown_decl
+        let enum_id = if let ty::TyDecl::EnumVariantDecl(ty::EnumVariantDecl { enum_ref, .. }) =
+            &unknown_decl
         {
-            (*decl_engine.get_enum(enum_ref.id())).clone()
+            *enum_ref.id()
         } else {
             // Check to see if this is a enum declaration.
-            let enum_ref = unknown_decl.to_enum_ref(handler, engines)?;
-            (*decl_engine.get_enum(enum_ref.id())).clone()
+            unknown_decl.to_enum_id(handler, engines)?
         };
 
+        let mut new_copy = (*decl_engine.get_enum(&enum_id)).clone();
+
         // Monomorphize the copy, in place.
         ctx.monomorphize(
             handler,
@@ -390,10 +462,11 @@ impl TypeCheckTypeBinding<ty::TyEnumDecl> for TypeBinding<CallPath> {
             &self.span,
         )?;
         // Insert the new copy into the declaration engine.
-        let new_enum_ref = ctx.engines.de().insert(new_copy);
+        let new_enum_ref =
+            decl_engine.insert(new_copy, decl_engine.get_parsed_decl_id(&enum_id).as_ref());
         let type_id = type_engine.insert(
             engines,
-            TypeInfo::Enum(new_enum_ref.clone()),
+            TypeInfo::Enum(*new_enum_ref.id()),
             new_enum_ref.span().source_id(),
         );
         Ok((new_enum_ref, Some(type_id), Some(unknown_decl)))
@@ -407,8 +480,9 @@ impl TypeBinding<QualifiedCallPath> {
         ctx: &mut TypeCheckContext,
     ) -> Result<DeclRef<DeclId<ty::TyConstantDecl>>, ErrorEmitted> {
         // Grab the declaration.
-        let unknown_decl =
-            ctx.resolve_qualified_call_path_with_visibility_check(handler, &self.inner)?;
+        let unknown_decl = ctx
+            .resolve_qualified_call_path_with_visibility_check(handler, &self.inner)?
+            .expect_typed();
 
         // Check to see if this is a const declaration.
         let const_ref = unknown_decl.to_const_ref(handler, ctx.engines())?;
@@ -431,7 +505,9 @@ impl TypeCheckTypeBinding<ty::TyConstantDecl> for TypeBinding<CallPath> {
         ErrorEmitted,
     > {
         // Grab the declaration.
-        let unknown_decl = ctx.resolve_call_path_with_visibility_check(handler, &self.inner)?;
+        let unknown_decl = ctx
+            .resolve_call_path_with_visibility_check(handler, &self.inner)?
+            .expect_typed();
 
         // Check to see if this is a const declaration.
         let const_ref = unknown_decl.to_const_ref(handler, ctx.engines())?;
diff --git a/sway-core/src/type_system/ast_elements/trait_constraint.rs b/sway-core/src/type_system/ast_elements/trait_constraint.rs
index 67e56d481c6..e91411595bb 100644
--- a/sway-core/src/type_system/ast_elements/trait_constraint.rs
+++ b/sway-core/src/type_system/ast_elements/trait_constraint.rs
@@ -15,11 +15,11 @@ use crate::{
     language::{parsed::Supertrait, ty, CallPath},
     semantic_analysis::{
         declaration::{insert_supertraits_into_namespace, SupertraitOf},
-        type_check_context::EnforceTypeArguments,
         TypeCheckContext,
     },
     type_system::priv_prelude::*,
     types::{CollectTypesMetadata, CollectTypesMetadataContext, TypeMetadata},
+    EnforceTypeArguments,
 };
 
 #[derive(Debug, Clone)]
@@ -98,8 +98,8 @@ impl Spanned for TraitConstraint {
 }
 
 impl SubstTypes for TraitConstraint {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.type_arguments.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.type_arguments.subst(ctx)
     }
 }
 
@@ -137,7 +137,7 @@ impl TraitConstraint {
     pub(crate) fn type_check(
         &mut self,
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
     ) -> Result<(), ErrorEmitted> {
         // Right now we don't have the ability to support defining a type for a
         // trait constraint using a callpath directly, so we check to see if the
diff --git a/sway-core/src/type_system/ast_elements/type_argument.rs b/sway-core/src/type_system/ast_elements/type_argument.rs
index 0d7f6af3ed6..1476fe6627b 100644
--- a/sway-core/src/type_system/ast_elements/type_argument.rs
+++ b/sway-core/src/type_system/ast_elements/type_argument.rs
@@ -109,7 +109,7 @@ impl From<&TypeParameter> for TypeArgument {
 }
 
 impl SubstTypes for TypeArgument {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.type_id.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.type_id.subst(ctx)
     }
 }
diff --git a/sway-core/src/type_system/ast_elements/type_parameter.rs b/sway-core/src/type_system/ast_elements/type_parameter.rs
index 13b8b69b77f..fb008336f4d 100644
--- a/sway-core/src/type_system/ast_elements/type_parameter.rs
+++ b/sway-core/src/type_system/ast_elements/type_parameter.rs
@@ -96,10 +96,10 @@ impl OrdWithEngines for TypeParameter {
 }
 
 impl SubstTypes for TypeParameter {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         has_changes! {
-            self.type_id.subst(type_mapping, engines);
-            self.trait_constraints.subst(type_mapping, engines);
+            self.type_id.subst(ctx);
+            self.trait_constraints.subst(ctx);
         }
     }
 }
@@ -110,6 +110,12 @@ impl Spanned for TypeParameter {
     }
 }
 
+impl IsConcrete for TypeParameter {
+    fn is_concrete(&self, engines: &Engines) -> bool {
+        self.type_id.is_concrete(engines, TreatNumericAs::Concrete)
+    }
+}
+
 impl DebugWithEngines for TypeParameter {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
         write!(f, "{}", self.name_ident)?;
@@ -352,6 +358,7 @@ impl TypeParameter {
 
         // Trait constraints mutate so we replace the previous type id associated TypeInfo.
         type_engine.replace(
+            ctx.engines(),
             type_parameter.type_id,
             TypeSourceInfo {
                 type_info: TypeInfo::UnknownGeneric {
@@ -441,6 +448,7 @@ impl TypeParameter {
                         }
 
                         ctx.engines.te().replace(
+                            ctx.engines(),
                             *type_id,
                             TypeSourceInfo {
                                 type_info: TypeInfo::UnknownGeneric {
@@ -499,22 +507,70 @@ impl TypeParameter {
                     ..
                 } = type_param;
 
-                // Check to see if the trait constraints are satisfied.
-                match ctx
-                    .namespace_mut()
-                    .module_mut(engines)
-                    .current_items_mut()
-                    .implemented_traits
-                    .check_if_trait_constraints_are_satisfied_for_type(
-                        handler,
-                        *type_id,
-                        trait_constraints,
-                        access_span,
-                        engines,
-                        TryInsertingTraitImplOnFailure::Yes,
-                    ) {
-                    Ok(res) => res,
-                    Err(_) => continue,
+                let code_block_first_pass = ctx.code_block_first_pass();
+                if !code_block_first_pass {
+                    // Tries to unify type id with a single existing trait implementation.
+                    // If more than one implementation exists we throw an error.
+                    // We only try to do the type inference from trait with a single trait constraint.
+                    if !type_id.is_concrete(engines, TreatNumericAs::Concrete) && trait_constraints.len() == 1 {
+                        let concrete_trait_type_ids : Vec<(TypeId, String)>= ctx
+                            .namespace_mut()
+                            .module(engines)
+                            .current_items()
+                            .implemented_traits
+                            .get_trait_constraints_are_satisfied_for_types(
+                                handler, *type_id, trait_constraints, engines,
+                            )?
+                            .into_iter()
+                            .filter_map(|t| {
+                                if t.0.is_concrete(engines, TreatNumericAs::Concrete) {
+                                    Some(t)
+                                } else {
+                                    None
+                                }
+                            }).collect();
+
+                        match concrete_trait_type_ids.len().cmp(&1) {
+                            Ordering::Equal => {
+                                ctx.engines.te().unify_with_generic(
+                                    handler,
+                                    engines,
+                                    *type_id,
+                                    concrete_trait_type_ids.first().unwrap().0,
+                                    access_span,
+                                    "Type parameter type does not match up with matched trait implementing type.",
+                                    None,
+                                );
+                            }
+                            Ordering::Greater => {
+                                return Err(handler.emit_err(CompileError::MultipleImplsSatisfyingTraitForType{
+                                    span:access_span.clone(),
+                                    type_annotation: engines.help_out(type_id).to_string(),
+                                    trait_names: trait_constraints.iter().map(|t| engines.help_out(t).to_string()).collect(),
+                                    trait_types_and_names: concrete_trait_type_ids.iter().map(|t| (engines.help_out(t.0).to_string(), t.1.clone())).collect::<Vec<_>>()
+                                }));
+                            }
+                            Ordering::Less => {}
+                        }
+                    }
+                    // Check to see if the trait constraints are satisfied.
+                    match ctx
+                        .namespace_mut()
+                        .module_mut(engines)
+                        .current_items_mut()
+                        .implemented_traits
+                        .check_if_trait_constraints_are_satisfied_for_type(
+                            handler,
+                            *type_id,
+                            trait_constraints,
+                            access_span,
+                            engines,
+                            TryInsertingTraitImplOnFailure::Yes,
+                            code_block_first_pass.into(),
+                        ) {
+                        Ok(res) => res,
+                        Err(_) => continue,
+                    }
                 }
 
                 for trait_constraint in trait_constraints {
diff --git a/sway-core/src/type_system/engine.rs b/sway-core/src/type_system/engine.rs
index 38871fd4108..7dea1cbb281 100644
--- a/sway-core/src/type_system/engine.rs
+++ b/sway-core/src/type_system/engine.rs
@@ -7,7 +7,7 @@ use crate::{
 use core::fmt::Write;
 use hashbrown::{hash_map::RawEntryMut, HashMap};
 use parking_lot::RwLock;
-use std::sync::Arc;
+use std::{sync::Arc, time::Instant};
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
@@ -17,10 +17,36 @@ use sway_types::{integer_bits::IntegerBits, span::Span, ProgramId, SourceId};
 
 use super::unify::unifier::UnifyKind;
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct TypeEngine {
     slab: ConcurrentSlab<TypeSourceInfo>,
     id_map: RwLock<HashMap<TypeSourceInfo, TypeId>>,
+    unifications: ConcurrentSlab<Unification>,
+    last_replace: RwLock<Instant>,
+}
+
+pub trait IsConcrete {
+    fn is_concrete(&self, engines: &Engines) -> bool;
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Unification {
+    pub received: TypeId,
+    pub expected: TypeId,
+    pub span: Span,
+    pub help_text: String,
+    pub unify_kind: UnifyKind,
+}
+
+impl Default for TypeEngine {
+    fn default() -> Self {
+        TypeEngine {
+            slab: Default::default(),
+            id_map: Default::default(),
+            unifications: Default::default(),
+            last_replace: RwLock::new(Instant::now()),
+        }
+    }
 }
 
 impl Clone for TypeEngine {
@@ -28,6 +54,8 @@ impl Clone for TypeEngine {
         TypeEngine {
             slab: self.slab.clone(),
             id_map: RwLock::new(self.id_map.read().clone()),
+            unifications: self.unifications.clone(),
+            last_replace: RwLock::new(*self.last_replace.read()),
         }
     }
 }
@@ -56,9 +84,7 @@ impl TypeEngine {
         });
         match raw_entry {
             RawEntryMut::Occupied(o) => return *o.get(),
-            RawEntryMut::Vacant(_) if ty.can_change(engines.de()) => {
-                TypeId::new(self.slab.insert(tsi))
-            }
+            RawEntryMut::Vacant(_) if ty.can_change(engines) => TypeId::new(self.slab.insert(tsi)),
             RawEntryMut::Vacant(v) => {
                 let type_id = TypeId::new(self.slab.insert(tsi.clone()));
                 v.insert_with_hasher(ty_hash, tsi, type_id, make_hasher(&hash_builder, engines));
@@ -67,19 +93,32 @@ impl TypeEngine {
         }
     }
 
+    fn clear_items<F>(&mut self, keep: F)
+    where
+        F: Fn(&SourceId) -> bool,
+    {
+        self.slab
+            .retain(|_, tsi| tsi.source_id.as_ref().map_or(true, &keep));
+        self.id_map
+            .write()
+            .retain(|tsi, _| tsi.source_id.as_ref().map_or(true, &keep));
+    }
+
     /// Removes all data associated with `program_id` from the type engine.
     pub fn clear_program(&mut self, program_id: &ProgramId) {
-        self.slab.retain(|_, tsi| match tsi.source_id {
-            Some(source_id) => &source_id.program_id() != program_id,
-            None => true,
-        });
-        self.id_map.write().retain(|tsi, _| match tsi.source_id {
-            Some(source_id) => &source_id.program_id() != program_id,
-            None => true,
-        });
+        self.clear_items(|id| id.program_id() != *program_id);
     }
 
-    pub fn replace(&self, id: TypeId, new_value: TypeSourceInfo) {
+    /// Removes all data associated with `source_id` from the type engine.
+    pub fn clear_module(&mut self, source_id: &SourceId) {
+        self.clear_items(|id| id != source_id);
+    }
+
+    pub fn replace(&self, engines: &Engines, id: TypeId, new_value: TypeSourceInfo) {
+        if !(*self.slab.get(id.index())).eq(&new_value, &PartialEqWithEnginesContext::new(engines))
+        {
+            self.touch_last_replace();
+        }
         self.slab.replace(id.index(), new_value);
     }
 
@@ -137,6 +176,7 @@ impl TypeEngine {
             help_text,
             err_override,
             UnifyKind::Default,
+            true,
         );
     }
 
@@ -167,6 +207,7 @@ impl TypeEngine {
             help_text,
             err_override,
             UnifyKind::WithSelf,
+            true,
         );
     }
 
@@ -197,9 +238,15 @@ impl TypeEngine {
             help_text,
             err_override,
             UnifyKind::WithGeneric,
+            true,
         );
     }
 
+    fn touch_last_replace(&self) {
+        let mut write_last_change = self.last_replace.write();
+        *write_last_change = Instant::now();
+    }
+
     #[allow(clippy::too_many_arguments)]
     fn unify_helper(
         handler: &Handler,
@@ -210,6 +257,7 @@ impl TypeEngine {
         help_text: &str,
         err_override: Option<CompileError>,
         unify_kind: UnifyKind,
+        push_unification: bool,
     ) {
         if !UnifyCheck::coercion(engines).check(received, expected) {
             // create a "mismatched type" error unless the `err_override`
@@ -224,11 +272,6 @@ impl TypeEngine {
                         received: engines.help_out(received).to_string(),
                         help_text: help_text.to_string(),
                         span: span.clone(),
-                        internal: format!(
-                            "expected:[{:?}]; received:[{:?}]",
-                            engines.help_out(expected),
-                            engines.help_out(received),
-                        ),
                     }));
                 }
             }
@@ -237,7 +280,7 @@ impl TypeEngine {
 
         let h = Handler::default();
         let unifier = Unifier::new(engines, help_text, unify_kind);
-        unifier.unify(handler, received, expected, span);
+        unifier.unify(handler, received, expected, span, push_unification);
 
         match err_override {
             Some(err_override) if h.has_errors() => {
@@ -249,6 +292,34 @@ impl TypeEngine {
         }
     }
 
+    pub(crate) fn push_unification(&self, unification: Unification) {
+        self.unifications.insert(unification);
+    }
+
+    pub(crate) fn clear_unifications(&self) {
+        self.unifications.clear();
+    }
+
+    pub(crate) fn reapply_unifications(&self, engines: &Engines) {
+        let current_last_replace = *self.last_replace.read();
+        for unification in self.unifications.values() {
+            Self::unify_helper(
+                &Handler::default(),
+                engines,
+                unification.received,
+                unification.expected,
+                &unification.span,
+                &unification.help_text,
+                None,
+                unification.unify_kind.clone(),
+                false,
+            )
+        }
+        if *self.last_replace.read() > current_last_replace {
+            self.reapply_unifications(engines);
+        }
+    }
+
     pub(crate) fn to_typeinfo(&self, id: TypeId, error_span: &Span) -> Result<TypeInfo, TypeError> {
         match &*self.get(id) {
             TypeInfo::Unknown => Err(TypeError::UnknownType {
@@ -259,33 +330,48 @@ impl TypeEngine {
     }
 
     /// Return whether a given type still contains undecayed references to [TypeInfo::Numeric]
-    pub(crate) fn contains_numeric(&self, decl_engine: &DeclEngine, type_id: TypeId) -> bool {
+    pub(crate) fn contains_numeric(&self, engines: &Engines, type_id: TypeId) -> bool {
+        let decl_engine = engines.de();
         match &&*self.get(type_id) {
+            TypeInfo::UntypedEnum(decl_id) => {
+                engines
+                    .pe()
+                    .get_enum(decl_id)
+                    .variants
+                    .iter()
+                    .all(|variant_type| {
+                        self.contains_numeric(engines, variant_type.type_argument.type_id)
+                    })
+            }
+            TypeInfo::UntypedStruct(decl_id) => engines
+                .pe()
+                .get_struct(decl_id)
+                .fields
+                .iter()
+                .any(|field| self.contains_numeric(engines, field.type_argument.type_id)),
             TypeInfo::Enum(decl_ref) => {
                 decl_engine
                     .get_enum(decl_ref)
                     .variants
                     .iter()
                     .all(|variant_type| {
-                        self.contains_numeric(decl_engine, variant_type.type_argument.type_id)
+                        self.contains_numeric(engines, variant_type.type_argument.type_id)
                     })
             }
             TypeInfo::Struct(decl_ref) => decl_engine
                 .get_struct(decl_ref)
                 .fields
                 .iter()
-                .any(|field| self.contains_numeric(decl_engine, field.type_argument.type_id)),
+                .any(|field| self.contains_numeric(engines, field.type_argument.type_id)),
             TypeInfo::Tuple(fields) => fields
                 .iter()
-                .any(|field_type| self.contains_numeric(decl_engine, field_type.type_id)),
-            TypeInfo::Array(elem_ty, _length) => {
-                self.contains_numeric(decl_engine, elem_ty.type_id)
-            }
-            TypeInfo::Ptr(targ) => self.contains_numeric(decl_engine, targ.type_id),
-            TypeInfo::Slice(targ) => self.contains_numeric(decl_engine, targ.type_id),
+                .any(|field_type| self.contains_numeric(engines, field_type.type_id)),
+            TypeInfo::Array(elem_ty, _length) => self.contains_numeric(engines, elem_ty.type_id),
+            TypeInfo::Ptr(targ) => self.contains_numeric(engines, targ.type_id),
+            TypeInfo::Slice(targ) => self.contains_numeric(engines, targ.type_id),
             TypeInfo::Ref {
                 referenced_type, ..
-            } => self.contains_numeric(decl_engine, referenced_type.type_id),
+            } => self.contains_numeric(engines, referenced_type.type_id),
             TypeInfo::Unknown
             | TypeInfo::Never
             | TypeInfo::UnknownGeneric { .. }
@@ -320,6 +406,16 @@ impl TypeEngine {
         let decl_engine = engines.de();
 
         match &&*self.get(type_id) {
+            TypeInfo::UntypedEnum(decl_id) => {
+                for variant_type in &engines.pe().get_enum(decl_id).variants {
+                    self.decay_numeric(handler, engines, variant_type.type_argument.type_id, span)?;
+                }
+            }
+            TypeInfo::UntypedStruct(decl_id) => {
+                for field in &engines.pe().get_struct(decl_id).fields {
+                    self.decay_numeric(handler, engines, field.type_argument.type_id, span)?;
+                }
+            }
             TypeInfo::Enum(decl_ref) => {
                 for variant_type in &decl_engine.get_enum(decl_ref).variants {
                     self.decay_numeric(handler, engines, variant_type.type_argument.type_id, span)?;
diff --git a/sway-core/src/type_system/id.rs b/sway-core/src/type_system/id.rs
index 3c9fe98c480..b1eda847745 100644
--- a/sway-core/src/type_system/id.rs
+++ b/sway-core/src/type_system/id.rs
@@ -6,18 +6,13 @@ use sway_error::{
 use sway_types::{BaseIdent, Span};
 
 use crate::{
-    engine_threading::{
-        DebugWithEngines, DisplayWithEngines, Engines, PartialEqWithEngines,
-        PartialEqWithEnginesContext, WithEngines,
-    },
+    decl_engine::DeclEngineGet,
+    engine_threading::{DebugWithEngines, DisplayWithEngines, Engines, WithEngines},
     language::CallPath,
-    semantic_analysis::type_check_context::EnforceTypeArguments,
     semantic_analysis::TypeCheckContext,
     type_system::priv_prelude::*,
-    types::{
-        CollectTypesMetadata, CollectTypesMetadataContext, TypeMetadata,
-        UnconstrainedTypeParameters,
-    },
+    types::{CollectTypesMetadata, CollectTypesMetadataContext, TypeMetadata},
+    EnforceTypeArguments,
 };
 
 use std::{
@@ -32,6 +27,11 @@ pub enum IncludeSelf {
     No,
 }
 
+pub enum TreatNumericAs {
+    Abstract,
+    Concrete,
+}
+
 /// A identifier to uniquely refer to our type terms
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Ord, PartialOrd, Debug)]
 pub struct TypeId(usize);
@@ -61,8 +61,10 @@ impl CollectTypesMetadata for TypeId {
         ctx: &mut CollectTypesMetadataContext,
     ) -> Result<Vec<TypeMetadata>, ErrorEmitted> {
         fn filter_fn(type_info: &TypeInfo) -> bool {
-            matches!(type_info, TypeInfo::UnknownGeneric { .. })
-                || matches!(type_info, TypeInfo::Placeholder(_))
+            matches!(
+                type_info,
+                TypeInfo::UnknownGeneric { .. } | TypeInfo::Placeholder(_)
+            )
         }
         let engines = ctx.engines;
         let possible = self.extract_any_including_self(engines, &filter_fn, vec![], 0);
@@ -89,9 +91,9 @@ impl CollectTypesMetadata for TypeId {
 }
 
 impl SubstTypes for TypeId {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        let type_engine = engines.te();
-        if let Some(matching_id) = type_mapping.find_match(*self, engines) {
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        let type_engine = ctx.engines.te();
+        if let Some(matching_id) = ctx.type_subst_map.find_match(*self, ctx.engines) {
             if !matches!(&*type_engine.get(matching_id), TypeInfo::ErrorRecovery(_)) {
                 *self = matching_id;
                 HasChanges::Yes
@@ -104,25 +106,6 @@ impl SubstTypes for TypeId {
     }
 }
 
-impl UnconstrainedTypeParameters for TypeId {
-    fn type_parameter_is_unconstrained(
-        &self,
-        engines: &Engines,
-        type_parameter: &TypeParameter,
-    ) -> bool {
-        let type_engine = engines.te();
-        let mut all_types: BTreeSet<TypeId> = self.extract_inner_types(engines, IncludeSelf::No);
-        all_types.insert(*self);
-        let type_parameter_info = type_engine.get(type_parameter.type_id);
-        all_types.iter().any(|type_id| {
-            type_engine.get(*type_id).eq(
-                &type_parameter_info,
-                &PartialEqWithEnginesContext::new(engines),
-            )
-        })
-    }
-}
-
 impl TypeId {
     pub(super) fn new(index: usize) -> TypeId {
         TypeId(index)
@@ -137,8 +120,8 @@ impl TypeId {
         let type_engine = engines.te();
         let decl_engine = engines.de();
         match &*type_engine.get(self) {
-            TypeInfo::Enum(decl_ref) => {
-                let decl = decl_engine.get_enum(decl_ref);
+            TypeInfo::Enum(decl_id) => {
+                let decl = decl_engine.get(decl_id);
                 (!decl.type_parameters.is_empty()).then_some(decl.type_parameters.clone())
             }
             TypeInfo::Struct(decl_ref) => {
@@ -245,6 +228,56 @@ impl TypeId {
             | TypeInfo::Contract
             | TypeInfo::ErrorRecovery(_)
             | TypeInfo::TraitType { .. } => {}
+            TypeInfo::UntypedEnum(decl_id) => {
+                let enum_decl = engines.pe().get_enum(decl_id);
+                for type_param in &enum_decl.type_parameters {
+                    extend(
+                        &mut found,
+                        type_param.type_id.extract_any_including_self(
+                            engines,
+                            filter_fn,
+                            type_param.trait_constraints.clone(),
+                            depth + 1,
+                        ),
+                    );
+                }
+                for variant in &enum_decl.variants {
+                    extend(
+                        &mut found,
+                        variant.type_argument.type_id.extract_any_including_self(
+                            engines,
+                            filter_fn,
+                            vec![],
+                            depth + 1,
+                        ),
+                    );
+                }
+            }
+            TypeInfo::UntypedStruct(decl_id) => {
+                let struct_decl = engines.pe().get_struct(decl_id);
+                for type_param in &struct_decl.type_parameters {
+                    extend(
+                        &mut found,
+                        type_param.type_id.extract_any_including_self(
+                            engines,
+                            filter_fn,
+                            type_param.trait_constraints.clone(),
+                            depth + 1,
+                        ),
+                    );
+                }
+                for field in &struct_decl.fields {
+                    extend(
+                        &mut found,
+                        field.type_argument.type_id.extract_any_including_self(
+                            engines,
+                            filter_fn,
+                            vec![],
+                            depth + 1,
+                        ),
+                    );
+                }
+            }
             TypeInfo::Enum(enum_ref) => {
                 let enum_decl = decl_engine.get_enum(enum_ref);
                 for type_param in &enum_decl.type_parameters {
@@ -270,8 +303,8 @@ impl TypeId {
                     );
                 }
             }
-            TypeInfo::Struct(struct_ref) => {
-                let struct_decl = decl_engine.get_struct(struct_ref);
+            TypeInfo::Struct(struct_id) => {
+                let struct_decl = decl_engine.get_struct(struct_id);
                 for type_param in &struct_decl.type_parameters {
                     extend(
                         &mut found,
@@ -480,17 +513,26 @@ impl TypeId {
         }))
     }
 
-    pub(crate) fn is_concrete(&self, engines: &Engines) -> bool {
+    pub(crate) fn is_concrete(&self, engines: &Engines, treat_numeric_as: TreatNumericAs) -> bool {
         let nested_types = (*self).extract_nested_types(engines);
-        !nested_types.into_iter().any(|x| {
-            matches!(
+        !nested_types.into_iter().any(|x| match treat_numeric_as {
+            TreatNumericAs::Abstract => matches!(
                 x,
                 TypeInfo::UnknownGeneric { .. }
                     | TypeInfo::Custom { .. }
                     | TypeInfo::Placeholder(..)
                     | TypeInfo::TraitType { .. }
                     | TypeInfo::TypeParam(..)
-            )
+                    | TypeInfo::Numeric
+            ),
+            TreatNumericAs::Concrete => matches!(
+                x,
+                TypeInfo::UnknownGeneric { .. }
+                    | TypeInfo::Custom { .. }
+                    | TypeInfo::Placeholder(..)
+                    | TypeInfo::TraitType { .. }
+                    | TypeInfo::TypeParam(..)
+            ),
         })
     }
 
@@ -521,6 +563,10 @@ impl TypeId {
         span: &Span,
         type_param: Option<TypeParameter>,
     ) -> Result<(), ErrorEmitted> {
+        if ctx.code_block_first_pass() {
+            return Ok(());
+        }
+
         let engines = ctx.engines();
 
         let mut structure_generics = self.extract_inner_types_with_trait_constraints(engines);
@@ -617,7 +663,7 @@ impl TypeId {
     fn check_trait_constraints_errors(
         self,
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         structure_type_id: &TypeId,
         structure_trait_constraints: &Vec<TraitConstraint>,
         f: impl Fn(&TraitConstraint),
diff --git a/sway-core/src/type_system/info.rs b/sway-core/src/type_system/info.rs
index e2fae0fd920..d4bcae5b8bf 100644
--- a/sway-core/src/type_system/info.rs
+++ b/sway-core/src/type_system/info.rs
@@ -1,10 +1,14 @@
 use crate::{
-    decl_engine::{DeclEngine, DeclEngineGet, DeclRefEnum, DeclRefStruct},
+    decl_engine::{parsed_id::ParsedDeclId, DeclEngine, DeclEngineGet, DeclId},
     engine_threading::{
         DebugWithEngines, DisplayWithEngines, Engines, EqWithEngines, HashWithEngines,
         OrdWithEngines, OrdWithEnginesContext, PartialEqWithEngines, PartialEqWithEnginesContext,
     },
-    language::{ty, CallPath, QualifiedCallPath},
+    language::{
+        parsed::{EnumDeclaration, StructDeclaration},
+        ty::{self, TyEnumDecl, TyStructDecl},
+        CallPath, QualifiedCallPath,
+    },
     type_system::priv_prelude::*,
     Ident,
 };
@@ -128,8 +132,10 @@ pub enum TypeInfo {
     StringSlice,
     StringArray(Length),
     UnsignedInteger(IntegerBits),
-    Enum(DeclRefEnum),
-    Struct(DeclRefStruct),
+    UntypedEnum(ParsedDeclId<EnumDeclaration>),
+    UntypedStruct(ParsedDeclId<StructDeclaration>),
+    Enum(DeclId<TyEnumDecl>),
+    Struct(DeclId<TyStructDecl>),
     Boolean,
     Tuple(Vec<TypeArgument>),
     /// Represents a type which contains methods to issue a contract call.
@@ -206,12 +212,14 @@ impl HashWithEngines for TypeInfo {
             TypeInfo::Tuple(fields) => {
                 fields.hash(state, engines);
             }
-            TypeInfo::Enum(decl_ref) => {
-                decl_ref.hash(state, engines);
+            TypeInfo::Enum(decl_id) => {
+                HashWithEngines::hash(&decl_id, state, engines);
             }
-            TypeInfo::Struct(decl_ref) => {
-                decl_ref.hash(state, engines);
+            TypeInfo::Struct(decl_id) => {
+                HashWithEngines::hash(&decl_id, state, engines);
             }
+            TypeInfo::UntypedEnum(decl_id) => decl_id.unique_id().hash(state),
+            TypeInfo::UntypedStruct(decl_id) => decl_id.unique_id().hash(state),
             TypeInfo::ContractCaller { abi_name, address } => {
                 abi_name.hash(state);
                 let address = address
@@ -376,7 +384,11 @@ impl PartialEqWithEngines for TypeInfo {
                     abi_name: r_abi_name,
                     address: r_address,
                 },
-            ) => l_abi_name == r_abi_name && l_address.as_deref().eq(&r_address.as_deref(), ctx),
+            ) => {
+                let l_address_span = l_address.as_ref().map(|x| x.span.clone());
+                let r_address_span = r_address.as_ref().map(|x| x.span.clone());
+                l_abi_name == r_abi_name && l_address_span == r_address_span
+            }
             (Self::Array(l0, l1), Self::Array(r0, r1)) => {
                 ((l0.type_id == r0.type_id)
                     || type_engine
@@ -485,9 +497,9 @@ impl OrdWithEngines for TypeInfo {
                 .then_with(|| l_root_type_id.cmp(r_root_type_id)),
             (Self::StringArray(l), Self::StringArray(r)) => l.val().cmp(&r.val()),
             (Self::UnsignedInteger(l), Self::UnsignedInteger(r)) => l.cmp(r),
-            (Self::Enum(l_decl_ref), Self::Enum(r_decl_ref)) => {
-                let l_decl = decl_engine.get_enum(l_decl_ref);
-                let r_decl = decl_engine.get_enum(r_decl_ref);
+            (Self::Enum(l_decl_id), Self::Enum(r_decl_id)) => {
+                let l_decl = decl_engine.get_enum(l_decl_id);
+                let r_decl = decl_engine.get_enum(r_decl_id);
                 l_decl
                     .call_path
                     .suffix
@@ -605,6 +617,22 @@ impl DisplayWithEngines for TypeInfo {
             Numeric => "numeric".into(),
             Contract => "contract".into(),
             ErrorRecovery(_) => "unknown".into(),
+            UntypedEnum(decl_id) => {
+                let decl = engines.pe().get_enum(decl_id);
+                print_inner_types(
+                    engines,
+                    decl.name.as_str(),
+                    decl.type_parameters.iter().map(|x| x.type_id),
+                )
+            }
+            UntypedStruct(decl_id) => {
+                let decl = engines.pe().get_struct(decl_id);
+                print_inner_types(
+                    engines,
+                    decl.name.as_str(),
+                    decl.type_parameters.iter().map(|x| x.type_id),
+                )
+            }
             Enum(decl_ref) => {
                 let decl = engines.de().get_enum(decl_ref);
                 print_inner_types(
@@ -656,16 +684,26 @@ impl DisplayWithEngines for TypeInfo {
 
 impl DebugWithEngines for TypeInfo {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
-        use TypeInfo::{
-            Alias, Array, Boolean, Contract, ContractCaller, Custom, Enum, ErrorRecovery, Never,
-            Numeric, Placeholder, Ptr, RawUntypedPtr, RawUntypedSlice, Ref, Slice, Storage,
-            StringArray, StringSlice, Struct, TraitType, Tuple, TypeParam, Unknown, UnknownGeneric,
-            UnsignedInteger, B256,
-        };
+        use TypeInfo::*;
         let s = match self {
             Unknown => "unknown".into(),
             Never => "!".into(),
-            UnknownGeneric { name, .. } => name.to_string(),
+            UnknownGeneric {
+                name,
+                trait_constraints,
+                ..
+            } => {
+                let tc_str = trait_constraints
+                    .iter()
+                    .map(|tc| engines.help_out(tc).to_string())
+                    .collect::<Vec<_>>()
+                    .join("+");
+                if tc_str.is_empty() {
+                    name.to_string()
+                } else {
+                    format!("{}:{}", name, tc_str)
+                }
+            }
             Placeholder(t) => format!("placeholder({:?})", engines.help_out(t)),
             TypeParam(n) => format!("typeparam({n})"),
             StringSlice => "str".into(),
@@ -710,6 +748,22 @@ impl DebugWithEngines for TypeInfo {
             Numeric => "numeric".into(),
             Contract => "contract".into(),
             ErrorRecovery(_) => "unknown due to error".into(),
+            UntypedEnum(decl_id) => {
+                let decl = engines.pe().get_enum(decl_id);
+                print_inner_types_debug(
+                    engines,
+                    decl.name.as_str(),
+                    decl.type_parameters.iter().map(|x| x.type_id),
+                )
+            }
+            UntypedStruct(decl_id) => {
+                let decl = engines.pe().get_struct(decl_id);
+                print_inner_types_debug(
+                    engines,
+                    decl.name.as_str(),
+                    decl.type_parameters.iter().map(|x| x.type_id),
+                )
+            }
             Enum(decl_ref) => {
                 let decl = engines.de().get_enum(decl_ref);
                 print_inner_types_debug(
@@ -804,6 +858,8 @@ impl TypeInfo {
             TypeInfo::TraitType { .. } => 24,
             TypeInfo::Ref { .. } => 25,
             TypeInfo::Never => 26,
+            TypeInfo::UntypedEnum(_) => 27,
+            TypeInfo::UntypedStruct(_) => 28,
         }
     }
 
@@ -1046,7 +1102,7 @@ impl TypeInfo {
             TypeInfo::Tuple(fields) => fields
                 .iter()
                 .any(|field_type| id_uninhabited(field_type.type_id)),
-            TypeInfo::Array(elem_ty, length) => length.val() > 0 && id_uninhabited(elem_ty.type_id),
+            TypeInfo::Array(elem_ty, _) => id_uninhabited(elem_ty.type_id),
             TypeInfo::Ptr(ty) => id_uninhabited(ty.type_id),
             TypeInfo::Alias { name: _, ty } => id_uninhabited(ty.type_id),
             TypeInfo::Slice(ty) => id_uninhabited(ty.type_id),
@@ -1172,6 +1228,16 @@ impl TypeInfo {
         matches!(self, TypeInfo::Ref { .. })
     }
 
+    pub fn as_reference(&self) -> Option<(&bool, &TypeArgument)> {
+        match self {
+            TypeInfo::Ref {
+                to_mutable_value,
+                referenced_type,
+            } => Some((to_mutable_value, referenced_type)),
+            _ => None,
+        }
+    }
+
     pub fn is_array(&self) -> bool {
         matches!(self, TypeInfo::Array(_, _))
     }
@@ -1188,6 +1254,18 @@ impl TypeInfo {
         matches!(self, TypeInfo::Tuple(_))
     }
 
+    pub fn is_slice(&self) -> bool {
+        matches!(self, TypeInfo::Slice(_))
+    }
+
+    pub fn as_slice(&self) -> Option<&TypeArgument> {
+        if let TypeInfo::Slice(t) = self {
+            Some(t)
+        } else {
+            None
+        }
+    }
+
     pub(crate) fn apply_type_arguments(
         self,
         handler: &Handler,
@@ -1198,12 +1276,13 @@ impl TypeInfo {
             return Ok(self);
         }
         match self {
-            TypeInfo::Enum { .. } | TypeInfo::Struct { .. } => {
-                Err(handler.emit_err(CompileError::Internal(
-                    "did not expect to apply type arguments to this type",
-                    span.clone(),
-                )))
-            }
+            TypeInfo::UntypedEnum(_)
+            | TypeInfo::UntypedStruct(_)
+            | TypeInfo::Enum { .. }
+            | TypeInfo::Struct { .. } => Err(handler.emit_err(CompileError::Internal(
+                "did not expect to apply type arguments to this type",
+                span.clone(),
+            ))),
             TypeInfo::Custom {
                 qualified_call_path: call_path,
                 type_arguments: other_type_arguments,
@@ -1258,11 +1337,12 @@ impl TypeInfo {
         engines: &Engines,
         span: &Span,
     ) -> Result<(), ErrorEmitted> {
-        const CURRENTLY_SUPPORTED_TYPES_MESSAGE: [&str; 8] = [
+        const CURRENTLY_SUPPORTED_TYPES_MESSAGE: [&str; 9] = [
             "Sway currently supports pattern matching on these types:",
             "  - b256",
             "  - boolean",
             "  - enums",
+            "  - string slices",
             "  - structs",
             "  - tuples",
             "  - unsigned integers",
@@ -1271,6 +1351,8 @@ impl TypeInfo {
 
         match self {
             TypeInfo::UnsignedInteger(_)
+            | TypeInfo::UntypedEnum(_)
+            | TypeInfo::UntypedStruct(_)
             | TypeInfo::Enum { .. }
             | TypeInfo::Struct { .. }
             | TypeInfo::Boolean
@@ -1278,7 +1360,8 @@ impl TypeInfo {
             | TypeInfo::B256
             | TypeInfo::UnknownGeneric { .. }
             | TypeInfo::Numeric
-            | TypeInfo::Never => Ok(()),
+            | TypeInfo::Never
+            | TypeInfo::StringSlice => Ok(()),
             TypeInfo::Alias { ty, .. } => {
                 let ty = engines.te().get(ty.type_id);
                 ty.expect_is_supported_in_match_expressions(handler, engines, span)
@@ -1288,7 +1371,6 @@ impl TypeInfo {
             | TypeInfo::Ptr(..)
             | TypeInfo::Slice(..)
             | TypeInfo::StringArray(_)
-            | TypeInfo::StringSlice
             | TypeInfo::Array(_, _) => Err(handler.emit_err(CompileError::Unimplemented {
                 feature: format!(
                     "Matched value has type \"{}\". Matching on this type",
@@ -1347,6 +1429,8 @@ impl TypeInfo {
         }
         match self {
             TypeInfo::UnsignedInteger(_)
+            | TypeInfo::UntypedEnum { .. }
+            | TypeInfo::UntypedStruct { .. }
             | TypeInfo::Enum { .. }
             | TypeInfo::Struct { .. }
             | TypeInfo::Boolean
@@ -1389,16 +1473,24 @@ impl TypeInfo {
         }
     }
 
-    pub(crate) fn can_change(&self, decl_engine: &DeclEngine) -> bool {
+    pub(crate) fn can_change(&self, engines: &Engines) -> bool {
         // TODO: there might be an optimization here that if the type params hold
         // only non-dynamic types, then it doesn't matter that there are type params
         match self {
+            TypeInfo::UntypedEnum(decl_id) => {
+                let decl = engines.pe().get_enum(decl_id);
+                !decl.type_parameters.is_empty()
+            }
+            TypeInfo::UntypedStruct(decl_id) => {
+                let decl = engines.pe().get_struct(decl_id);
+                !decl.type_parameters.is_empty()
+            }
             TypeInfo::Enum(decl_ref) => {
-                let decl = decl_engine.get_enum(decl_ref);
+                let decl = engines.de().get_enum(decl_ref);
                 !decl.type_parameters.is_empty()
             }
             TypeInfo::Struct(decl_ref) => {
-                let decl = decl_engine.get_struct(decl_ref);
+                let decl = engines.de().get_struct(decl_ref);
                 !decl.type_parameters.is_empty()
             }
             TypeInfo::StringArray(_)
@@ -1409,7 +1501,6 @@ impl TypeInfo {
             | TypeInfo::RawUntypedPtr
             | TypeInfo::RawUntypedSlice
             | TypeInfo::Ptr(_)
-            | TypeInfo::Slice(_)
             | TypeInfo::ErrorRecovery(_)
             | TypeInfo::TraitType { .. }
             | TypeInfo::Never => false,
@@ -1419,6 +1510,7 @@ impl TypeInfo {
             | TypeInfo::Custom { .. }
             | TypeInfo::Tuple(_)
             | TypeInfo::Array(_, _)
+            | TypeInfo::Slice(_)
             | TypeInfo::Contract
             | TypeInfo::Storage { .. }
             | TypeInfo::Numeric
@@ -1464,9 +1556,9 @@ impl TypeInfo {
         engines: &Engines,
         debug_string: impl Into<String>,
         debug_span: &Span,
-    ) -> Result<DeclRefEnum, ErrorEmitted> {
+    ) -> Result<DeclId<TyEnumDecl>, ErrorEmitted> {
         match self {
-            TypeInfo::Enum(decl_ref) => Ok(decl_ref.clone()),
+            TypeInfo::Enum(decl_ref) => Ok(*decl_ref),
             TypeInfo::Alias {
                 ty: TypeArgument { type_id, .. },
                 ..
@@ -1505,9 +1597,9 @@ impl TypeInfo {
         handler: &Handler,
         engines: &Engines,
         debug_span: &Span,
-    ) -> Result<DeclRefStruct, ErrorEmitted> {
+    ) -> Result<DeclId<TyStructDecl>, ErrorEmitted> {
         match self {
-            TypeInfo::Struct(decl_ref) => Ok(decl_ref.clone()),
+            TypeInfo::Struct(decl_id) => Ok(*decl_id),
             TypeInfo::Alias {
                 ty: TypeArgument { type_id, .. },
                 ..
@@ -1578,8 +1670,8 @@ impl TypeInfo {
                     })
             }
 
-            TypeInfo::Struct(s) => {
-                let decl = engines.de().get(s.id());
+            TypeInfo::Struct(decl_id) => {
+                let decl = engines.de().get(decl_id);
                 decl.fields
                     .iter()
                     .fold(AbiEncodeSizeHint::Exact(0), |old_size_hint, f| {
@@ -1588,8 +1680,8 @@ impl TypeInfo {
                         old_size_hint + field_size_hint
                     })
             }
-            TypeInfo::Enum(e) => {
-                let decl = engines.de().get(e.id());
+            TypeInfo::Enum(decl_id) => {
+                let decl = engines.de().get(decl_id);
 
                 let min = decl
                     .variants
@@ -1657,6 +1749,38 @@ impl TypeInfo {
             Numeric => "u64".into(), // u64 is the default
             Contract => "contract".into(),
             ErrorRecovery(_) => "unknown due to error".into(),
+            UntypedEnum(decl_id) => {
+                let decl = engines.pe().get_enum(decl_id);
+                let type_params = if decl.type_parameters.is_empty() {
+                    "".into()
+                } else {
+                    format!(
+                        "<{}>",
+                        decl.type_parameters
+                            .iter()
+                            .map(|p| p.type_id.get_type_str(engines))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                };
+                format!("untyped enum {}{}", &decl.name, type_params)
+            }
+            UntypedStruct(decl_id) => {
+                let decl = engines.pe().get_struct(decl_id);
+                let type_params = if decl.type_parameters.is_empty() {
+                    "".into()
+                } else {
+                    format!(
+                        "<{}>",
+                        decl.type_parameters
+                            .iter()
+                            .map(|p| p.type_id.get_type_str(engines))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                };
+                format!("untyped struct {}{}", &decl.name, type_params)
+            }
             Enum(decl_ref) => {
                 let decl = engines.de().get_enum(decl_ref);
                 let type_params = if decl.type_parameters.is_empty() {
diff --git a/sway-core/src/type_system/mod.rs b/sway-core/src/type_system/mod.rs
index 7e789a792ba..37446b5843c 100644
--- a/sway-core/src/type_system/mod.rs
+++ b/sway-core/src/type_system/mod.rs
@@ -1,14 +1,17 @@
-mod ast_elements;
+pub(crate) mod ast_elements;
 mod engine;
 mod id;
 mod info;
+pub(crate) mod monomorphization;
 mod priv_prelude;
 mod substitute;
-mod unify;
+pub(crate) mod unify;
 
 #[allow(unused)]
 use std::ops::Deref;
 
+pub use substitute::subst_types::SubstTypesContext;
+
 #[cfg(test)]
 use crate::language::CallPath;
 #[cfg(test)]
@@ -21,6 +24,41 @@ use sway_types::BaseIdent;
 #[cfg(test)]
 use sway_types::{integer_bits::IntegerBits, Span};
 
+/// This type is used to denote if, during monomorphization, the compiler
+/// should enforce that type arguments be provided. An example of that
+/// might be this:
+///
+/// ```ignore
+/// struct Point<T> {
+///   x: u64,
+///   y: u64
+/// }
+///
+/// fn add<T>(p1: Point<T>, p2: Point<T>) -> Point<T> {
+///   Point {
+///     x: p1.x + p2.x,
+///     y: p1.y + p2.y
+///   }
+/// }
+/// ```
+///
+/// `EnforceTypeArguments` would require that the type annotations
+/// for `p1` and `p2` contain `<...>`. This is to avoid ambiguous definitions:
+///
+/// ```ignore
+/// fn add(p1: Point, p2: Point) -> Point {
+///   Point {
+///     x: p1.x + p2.x,
+///     y: p1.y + p2.y
+///   }
+/// }
+/// ```
+#[derive(Clone, Copy)]
+pub(crate) enum EnforceTypeArguments {
+    Yes,
+    No,
+}
+
 #[test]
 fn generic_enum_resolution() {
     use crate::{
@@ -84,17 +122,20 @@ fn generic_enum_resolution() {
 
     let mut call_path: CallPath<BaseIdent> = result_name.clone().into();
     call_path.is_absolute = true;
-    let decl_ref_1 = engines.de().insert(TyEnumDecl {
-        call_path,
-        type_parameters: vec![placeholder_type_param],
-        variants: variant_types,
-        span: sp.clone(),
-        visibility: crate::language::Visibility::Public,
-        attributes: AttributesMap::default(),
-    });
+    let decl_ref_1 = engines.de().insert(
+        TyEnumDecl {
+            call_path,
+            type_parameters: vec![placeholder_type_param],
+            variants: variant_types,
+            span: sp.clone(),
+            visibility: crate::language::Visibility::Public,
+            attributes: AttributesMap::default(),
+        },
+        None,
+    );
     let ty_1 = engines
         .te()
-        .insert(&engines, TypeInfo::Enum(decl_ref_1), None);
+        .insert(&engines, TypeInfo::Enum(*decl_ref_1.id()), None);
 
     /*
     Result<bool> {
@@ -125,17 +166,20 @@ fn generic_enum_resolution() {
 
     let mut call_path: CallPath<BaseIdent> = result_name.into();
     call_path.is_absolute = true;
-    let decl_ref_2 = engines.de().insert(TyEnumDecl {
-        call_path,
-        type_parameters: vec![type_param],
-        variants: variant_types.clone(),
-        span: sp.clone(),
-        visibility: crate::language::Visibility::Public,
-        attributes: AttributesMap::default(),
-    });
+    let decl_ref_2 = engines.de().insert(
+        TyEnumDecl {
+            call_path,
+            type_parameters: vec![type_param],
+            variants: variant_types.clone(),
+            span: sp.clone(),
+            visibility: crate::language::Visibility::Public,
+            attributes: AttributesMap::default(),
+        },
+        None,
+    );
     let ty_2 = engines
         .te()
-        .insert(&engines, TypeInfo::Enum(decl_ref_2), None);
+        .insert(&engines, TypeInfo::Enum(*decl_ref_2.id()), None);
 
     // Unify them together...
     let h = Handler::default();
diff --git a/sway-core/src/type_system/monomorphization.rs b/sway-core/src/type_system/monomorphization.rs
new file mode 100644
index 00000000000..674650896db
--- /dev/null
+++ b/sway-core/src/type_system/monomorphization.rs
@@ -0,0 +1,347 @@
+use sway_error::{
+    error::CompileError,
+    handler::{ErrorEmitted, Handler},
+};
+use sway_types::{Ident, Span, Spanned};
+
+use crate::{
+    decl_engine::{engine::DeclEngineGetParsedDeclId, DeclEngineInsert},
+    language::{
+        ty::{self},
+        CallPath,
+    },
+    namespace::{ModulePath, ResolvedDeclaration},
+    semantic_analysis::type_resolve::resolve_type,
+    type_system::ast_elements::create_type_id::CreateTypeId,
+    EnforceTypeArguments, Engines, Namespace, SubstTypes, SubstTypesContext, TypeArgument, TypeId,
+    TypeInfo, TypeParameter, TypeSubstMap,
+};
+
+pub(crate) trait MonomorphizeHelper {
+    fn name(&self) -> &Ident;
+    fn type_parameters(&self) -> &[TypeParameter];
+    fn has_self_type_param(&self) -> bool;
+}
+
+/// Given a `value` of type `T` that is able to be monomorphized and a set
+/// of `type_arguments`, prepare a `TypeSubstMap` that can be used as an
+/// input for monomorphization.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn prepare_type_subst_map_for_monomorphize<T>(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &Namespace,
+    value: &T,
+    type_arguments: &mut [TypeArgument],
+    enforce_type_arguments: EnforceTypeArguments,
+    call_site_span: &Span,
+    mod_path: &ModulePath,
+    self_type: Option<TypeId>,
+    subst_ctx: &SubstTypesContext,
+) -> Result<TypeSubstMap, ErrorEmitted>
+where
+    T: MonomorphizeHelper + SubstTypes,
+{
+    fn make_type_arity_mismatch_error(
+        name: Ident,
+        span: Span,
+        given: usize,
+        expected: usize,
+    ) -> CompileError {
+        match (expected, given) {
+            (0, 0) => unreachable!(),
+            (_, 0) => CompileError::NeedsTypeArguments { name, span },
+            (0, _) => CompileError::DoesNotTakeTypeArguments { name, span },
+            (_, _) => CompileError::IncorrectNumberOfTypeArguments {
+                name,
+                given,
+                expected,
+                span,
+            },
+        }
+    }
+
+    match (value.type_parameters().len(), type_arguments.len()) {
+        (0, 0) => Ok(TypeSubstMap::default()),
+        (num_type_params, 0) => {
+            if let EnforceTypeArguments::Yes = enforce_type_arguments {
+                return Err(handler.emit_err(make_type_arity_mismatch_error(
+                    value.name().clone(),
+                    call_site_span.clone(),
+                    0,
+                    num_type_params,
+                )));
+            }
+            let type_mapping = TypeSubstMap::from_type_parameters(engines, value.type_parameters());
+            Ok(type_mapping)
+        }
+        (0, num_type_args) => {
+            let type_arguments_span = type_arguments
+                .iter()
+                .map(|x| x.span.clone())
+                .reduce(|s1: Span, s2: Span| Span::join(s1, &s2))
+                .unwrap_or_else(|| value.name().span());
+            Err(handler.emit_err(make_type_arity_mismatch_error(
+                value.name().clone(),
+                type_arguments_span.clone(),
+                num_type_args,
+                0,
+            )))
+        }
+        (_, num_type_args) => {
+            // a trait decl is passed the self type parameter and the corresponding argument
+            // but it would be confusing for the user if the error reporting mechanism
+            // reported the number of arguments including the implicit self, hence
+            // we adjust it below
+            let adjust_for_trait_decl = value.has_self_type_param() as usize;
+            let non_parent_type_params = value
+                .type_parameters()
+                .iter()
+                .filter(|x| !x.is_from_parent)
+                .count()
+                - adjust_for_trait_decl;
+
+            let num_type_args = num_type_args - adjust_for_trait_decl;
+            if non_parent_type_params != num_type_args {
+                let type_arguments_span = type_arguments
+                    .iter()
+                    .map(|x| x.span.clone())
+                    .reduce(|s1: Span, s2: Span| Span::join(s1, &s2))
+                    .unwrap_or_else(|| value.name().span());
+
+                return Err(handler.emit_err(make_type_arity_mismatch_error(
+                    value.name().clone(),
+                    type_arguments_span,
+                    num_type_args,
+                    non_parent_type_params,
+                )));
+            }
+
+            for type_argument in type_arguments.iter_mut() {
+                type_argument.type_id = resolve_type(
+                    handler,
+                    engines,
+                    namespace,
+                    mod_path,
+                    type_argument.type_id,
+                    &type_argument.span,
+                    enforce_type_arguments,
+                    None,
+                    self_type,
+                    subst_ctx,
+                )
+                .unwrap_or_else(|err| {
+                    engines
+                        .te()
+                        .insert(engines, TypeInfo::ErrorRecovery(err), None)
+                });
+            }
+            let type_mapping = TypeSubstMap::from_type_parameters_and_type_arguments(
+                value
+                    .type_parameters()
+                    .iter()
+                    .map(|type_param| type_param.type_id)
+                    .collect(),
+                type_arguments
+                    .iter()
+                    .map(|type_arg| type_arg.type_id)
+                    .collect(),
+            );
+            Ok(type_mapping)
+        }
+    }
+}
+
+/// Given a `value` of type `T` that is able to be monomorphized and a set
+/// of `type_arguments`, monomorphize `value` with the `type_arguments`.
+///
+/// When this function is called, it is passed a `T` that is a copy of some
+/// original declaration for `T` (let's denote the original with `[T]`).
+/// Because monomorphization happens at application time (e.g. function
+/// application), we want to be able to modify `value` such that type
+/// checking the application of `value` affects only `T` and not `[T]`.
+///
+/// So, at a high level, this function does two things. It 1) performs the
+/// necessary work to refresh the relevant generic types in `T` so that they
+/// are distinct from the generics of the same name in `[T]`. And it 2)
+/// applies `type_arguments` (if any are provided) to the type parameters
+/// of `value`, unifying the types.
+///
+/// There are 4 cases that are handled in this function:
+///
+/// 1. `value` does not have type parameters + `type_arguments` is empty:
+///     1a. return ok
+/// 2. `value` has type parameters + `type_arguments` is empty:
+///     2a. if the [EnforceTypeArguments::Yes] variant is provided, then
+///         error
+///     2b. refresh the generic types with a [TypeSubstMapping]
+/// 3. `value` does have type parameters + `type_arguments` is nonempty:
+///     3a. error
+/// 4. `value` has type parameters + `type_arguments` is nonempty:
+///     4a. check to see that the type parameters and `type_arguments` have
+///         the same length
+///     4b. for each type argument in `type_arguments`, resolve the type
+///     4c. refresh the generic types with a [TypeSubstMapping]
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn monomorphize_with_modpath<T>(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &Namespace,
+    value: &mut T,
+    type_arguments: &mut [TypeArgument],
+    enforce_type_arguments: EnforceTypeArguments,
+    call_site_span: &Span,
+    mod_path: &ModulePath,
+    self_type: Option<TypeId>,
+    subst_ctx: &SubstTypesContext,
+) -> Result<(), ErrorEmitted>
+where
+    T: MonomorphizeHelper + SubstTypes,
+{
+    let type_mapping = prepare_type_subst_map_for_monomorphize(
+        handler,
+        engines,
+        namespace,
+        value,
+        type_arguments,
+        enforce_type_arguments,
+        call_site_span,
+        mod_path,
+        self_type,
+        subst_ctx,
+    )?;
+    value.subst(&SubstTypesContext::new(engines, &type_mapping, true));
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn type_decl_opt_to_type_id(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &Namespace,
+    type_decl_opt: Option<ResolvedDeclaration>,
+    call_path: &CallPath,
+    span: &Span,
+    enforce_type_arguments: EnforceTypeArguments,
+    mod_path: &ModulePath,
+    type_arguments: Option<Vec<TypeArgument>>,
+    self_type: Option<TypeId>,
+    subst_ctx: &SubstTypesContext,
+) -> Result<TypeId, ErrorEmitted> {
+    let decl_engine = engines.de();
+    let type_engine = engines.te();
+    Ok(match type_decl_opt {
+        Some(ResolvedDeclaration::Typed(ty::TyDecl::StructDecl(ty::StructDecl {
+            decl_id: original_id,
+            ..
+        }))) => {
+            // get the copy from the declaration engine
+            let mut new_copy = (*decl_engine.get_struct(&original_id)).clone();
+
+            // monomorphize the copy, in place
+            monomorphize_with_modpath(
+                handler,
+                engines,
+                namespace,
+                &mut new_copy,
+                &mut type_arguments.unwrap_or_default(),
+                enforce_type_arguments,
+                span,
+                mod_path,
+                self_type,
+                subst_ctx,
+            )?;
+
+            // insert the new copy in the decl engine
+            let new_decl_ref = decl_engine.insert(
+                new_copy,
+                decl_engine.get_parsed_decl_id(&original_id).as_ref(),
+            );
+
+            // create the type id from the copy
+            type_engine.insert(
+                engines,
+                TypeInfo::Struct(*new_decl_ref.id()),
+                new_decl_ref.span().source_id(),
+            )
+        }
+        Some(ResolvedDeclaration::Typed(ty::TyDecl::EnumDecl(ty::EnumDecl {
+            decl_id: original_id,
+            ..
+        }))) => {
+            // get the copy from the declaration engine
+            let mut new_copy = (*decl_engine.get_enum(&original_id)).clone();
+
+            // monomorphize the copy, in place
+            monomorphize_with_modpath(
+                handler,
+                engines,
+                namespace,
+                &mut new_copy,
+                &mut type_arguments.unwrap_or_default(),
+                enforce_type_arguments,
+                span,
+                mod_path,
+                self_type,
+                subst_ctx,
+            )?;
+
+            // insert the new copy in the decl engine
+            let new_decl_ref = decl_engine.insert(
+                new_copy,
+                decl_engine.get_parsed_decl_id(&original_id).as_ref(),
+            );
+
+            // create the type id from the copy
+            type_engine.insert(
+                engines,
+                TypeInfo::Enum(*new_decl_ref.id()),
+                new_decl_ref.span().source_id(),
+            )
+        }
+        Some(ResolvedDeclaration::Typed(ty::TyDecl::TypeAliasDecl(ty::TypeAliasDecl {
+            decl_id: original_id,
+            ..
+        }))) => {
+            let new_copy = decl_engine.get_type_alias(&original_id);
+
+            // TODO: monomorphize the copy, in place, when generic type aliases are
+            // supported
+
+            new_copy.create_type_id(engines)
+        }
+        Some(ResolvedDeclaration::Typed(ty::TyDecl::GenericTypeForFunctionScope(
+            ty::GenericTypeForFunctionScope { type_id, .. },
+        ))) => type_id,
+        Some(ResolvedDeclaration::Typed(ty::TyDecl::TraitTypeDecl(ty::TraitTypeDecl {
+            decl_id,
+        }))) => {
+            let decl_type = decl_engine.get_type(&decl_id);
+
+            if let Some(ty) = &decl_type.ty {
+                ty.type_id
+            } else if let Some(implementing_type) = self_type {
+                type_engine.insert(
+                    engines,
+                    TypeInfo::TraitType {
+                        name: decl_type.name.clone(),
+                        trait_type_id: implementing_type,
+                    },
+                    decl_type.name.span().source_id(),
+                )
+            } else {
+                return Err(handler.emit_err(CompileError::Internal(
+                    "Self type not provided.",
+                    span.clone(),
+                )));
+            }
+        }
+        _ => {
+            let err = handler.emit_err(CompileError::UnknownTypeName {
+                name: call_path.to_string(),
+                span: call_path.span(),
+            });
+            type_engine.insert(engines, TypeInfo::ErrorRecovery(err), None)
+        }
+    })
+}
diff --git a/sway-core/src/type_system/priv_prelude.rs b/sway-core/src/type_system/priv_prelude.rs
index bb40d738d00..fdf2a4138a9 100644
--- a/sway-core/src/type_system/priv_prelude.rs
+++ b/sway-core/src/type_system/priv_prelude.rs
@@ -6,7 +6,11 @@ pub(crate) use super::{
         create_type_id::CreateTypeId,
     },
     info::VecSet,
-    substitute::{subst_map::TypeSubstMap, subst_types::HasChanges, subst_types::SubstTypes},
+    substitute::{
+        subst_map::TypeSubstMap,
+        subst_types::HasChanges,
+        subst_types::{SubstTypes, SubstTypesContext},
+    },
     unify::unify_check::UnifyCheck,
 };
 
@@ -15,7 +19,8 @@ pub use super::{
         length::Length, trait_constraint::TraitConstraint, type_argument::TypeArgument,
         type_parameter::TypeParameter,
     },
+    engine::IsConcrete,
     engine::TypeEngine,
-    id::{IncludeSelf, TypeId},
+    id::{IncludeSelf, TreatNumericAs, TypeId},
     info::{AbiEncodeSizeHint, AbiName, TypeInfo, TypeSourceInfo},
 };
diff --git a/sway-core/src/type_system/substitute/subst_list.rs b/sway-core/src/type_system/substitute/subst_list.rs
deleted file mode 100644
index ac63696608c..00000000000
--- a/sway-core/src/type_system/substitute/subst_list.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use std::{
-    hash::Hasher,
-    slice::{Iter, IterMut},
-    vec::IntoIter,
-};
-
-use crate::{
-    engine_threading::{
-        Engines, EqWithEngines, HashWithEngines, OrdWithEngines, OrdWithEnginesContext,
-        PartialEqWithEngines, PartialEqWithEnginesContext,
-    },
-    type_system::priv_prelude::*,
-};
-
-/// A list of types that serve as the list of type params for type substitution.
-/// Any types of the [TypeParam][TypeInfo::TypeParam] variant will point to an
-/// index in this list.
-#[derive(Debug, Clone, Default)]
-pub struct SubstList {
-    list: Vec<TypeParameter>,
-}
-
-impl SubstList {
-    pub(crate) fn new() -> SubstList {
-        SubstList { list: vec![] }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn is_empty(&self) -> bool {
-        self.list.is_empty()
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn len(&self) -> usize {
-        self.list.len()
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn push(&mut self, type_param: TypeParameter) {
-        self.list.push(type_param);
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn iter(&self) -> Iter<'_, TypeParameter> {
-        self.list.iter()
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn into_iter(self) -> IntoIter<TypeParameter> {
-        self.list.into_iter()
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn iter_mut(&mut self) -> IterMut<'_, TypeParameter> {
-        self.list.iter_mut()
-    }
-}
-
-impl std::iter::FromIterator<TypeParameter> for SubstList {
-    fn from_iter<T: IntoIterator<Item = TypeParameter>>(iter: T) -> Self {
-        SubstList {
-            list: iter.into_iter().collect::<Vec<TypeParameter>>(),
-        }
-    }
-}
-
-impl EqWithEngines for SubstList {}
-impl PartialEqWithEngines for SubstList {
-    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
-        self.list.eq(&other.list, ctx)
-    }
-}
-
-impl HashWithEngines for SubstList {
-    fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
-        self.list.hash(state, engines);
-    }
-}
-
-impl OrdWithEngines for SubstList {
-    fn cmp(&self, other: &Self, ctx: &OrdWithEnginesContext) -> std::cmp::Ordering {
-        let SubstList { list: ll } = self;
-        let SubstList { list: rl } = other;
-        ll.cmp(rl, ctx)
-    }
-}
-
-impl SubstTypes for SubstList {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.list.subst(type_mapping, engines)
-    }
-}
diff --git a/sway-core/src/type_system/substitute/subst_map.rs b/sway-core/src/type_system/substitute/subst_map.rs
index c23cad1e9b2..4b1a9fa93c7 100644
--- a/sway-core/src/type_system/substitute/subst_map.rs
+++ b/sway-core/src/type_system/substitute/subst_map.rs
@@ -1,5 +1,7 @@
 use crate::{
-    decl_engine::{DeclEngine, DeclEngineInsert},
+    decl_engine::{
+        DeclEngine, DeclEngineGetParsedDeclId, DeclEngineInsert, ParsedDeclEngineInsert,
+    },
     engine_threading::{
         DebugWithEngines, Engines, PartialEqWithEngines, PartialEqWithEnginesContext,
     },
@@ -65,6 +67,15 @@ impl TypeSubstMap {
         }
     }
 
+    pub(crate) fn source_ids_contains_concrete_type(&self, engines: &Engines) -> bool {
+        for source_id in self.mapping.keys() {
+            if source_id.is_concrete(engines, TreatNumericAs::Concrete) {
+                return true;
+            }
+        }
+        false
+    }
+
     /// Constructs a new [TypeSubstMap] from a list of [TypeParameter]s
     /// `type_parameters`. The [SourceType]s of the resulting [TypeSubstMap] are
     /// the [TypeId]s from `type_parameters` and the [DestinationType]s are the
@@ -76,13 +87,17 @@ impl TypeSubstMap {
         let type_engine = engines.te();
         let mapping = type_parameters
             .iter()
-            .map(|x| {
+            .filter(|type_param| {
+                let type_info = type_engine.get(type_param.type_id);
+                !matches!(*type_info, TypeInfo::Placeholder(_))
+            })
+            .map(|type_param| {
                 (
-                    x.type_id,
+                    type_param.type_id,
                     type_engine.insert(
                         engines,
-                        TypeInfo::Placeholder(x.clone()),
-                        x.name_ident.span().source_id(),
+                        TypeInfo::Placeholder(type_param.clone()),
+                        type_param.name_ident.span().source_id(),
                     ),
                 )
             })
@@ -233,6 +248,14 @@ impl TypeSubstMap {
                     vec![type_argument.type_id],
                 )
             }
+            (TypeInfo::Slice(type_parameter), TypeInfo::Slice(type_argument)) => {
+                TypeSubstMap::from_superset_and_subset_helper(
+                    type_engine,
+                    decl_engine,
+                    vec![type_parameter.type_id],
+                    vec![type_argument.type_id],
+                )
+            }
             (
                 TypeInfo::Storage {
                     fields: type_parameters,
@@ -336,14 +359,44 @@ impl TypeSubstMap {
     pub(crate) fn find_match(&self, type_id: TypeId, engines: &Engines) -> Option<TypeId> {
         let type_engine = engines.te();
         let decl_engine = engines.de();
+        let parsed_decl_engine = engines.pe();
         let type_info = type_engine.get(type_id);
         match (*type_info).clone() {
             TypeInfo::Custom { .. } => iter_for_match(engines, self, &type_info),
             TypeInfo::UnknownGeneric { .. } => iter_for_match(engines, self, &type_info),
             TypeInfo::Placeholder(_) => iter_for_match(engines, self, &type_info),
             TypeInfo::TypeParam(_) => None,
-            TypeInfo::Struct(decl_ref) => {
-                let mut decl = (*decl_engine.get_struct(&decl_ref)).clone();
+            TypeInfo::UntypedEnum(decl_id) => {
+                let mut decl = (*parsed_decl_engine.get_enum(&decl_id)).clone();
+                let mut need_to_create_new = false;
+
+                for variant in &mut decl.variants {
+                    if let Some(type_id) = self.find_match(variant.type_argument.type_id, engines) {
+                        need_to_create_new = true;
+                        variant.type_argument.type_id = type_id;
+                    }
+                }
+
+                for type_param in &mut decl.type_parameters {
+                    if let Some(type_id) = self.find_match(type_param.type_id, engines) {
+                        need_to_create_new = true;
+                        type_param.type_id = type_id;
+                    }
+                }
+                if need_to_create_new {
+                    let source_id = decl.span.source_id().copied();
+                    let new_decl_id = engines.pe().insert(decl);
+                    Some(type_engine.insert(
+                        engines,
+                        TypeInfo::UntypedEnum(new_decl_id),
+                        source_id.as_ref(),
+                    ))
+                } else {
+                    None
+                }
+            }
+            TypeInfo::UntypedStruct(decl_id) => {
+                let mut decl = (*parsed_decl_engine.get_struct(&decl_id)).clone();
                 let mut need_to_create_new = false;
                 for field in &mut decl.fields {
                     if let Some(type_id) = self.find_match(field.type_argument.type_id, engines) {
@@ -358,18 +411,46 @@ impl TypeSubstMap {
                     }
                 }
                 if need_to_create_new {
-                    let new_decl_ref = decl_engine.insert(decl);
+                    let source_id = decl.span.source_id().copied();
+                    let new_decl_id = parsed_decl_engine.insert(decl);
                     Some(type_engine.insert(
                         engines,
-                        TypeInfo::Struct(new_decl_ref.clone()),
+                        TypeInfo::UntypedStruct(new_decl_id),
+                        source_id.as_ref(),
+                    ))
+                } else {
+                    None
+                }
+            }
+            TypeInfo::Struct(decl_id) => {
+                let mut decl = (*decl_engine.get_struct(&decl_id)).clone();
+                let mut need_to_create_new = false;
+                for field in &mut decl.fields {
+                    if let Some(type_id) = self.find_match(field.type_argument.type_id, engines) {
+                        need_to_create_new = true;
+                        field.type_argument.type_id = type_id;
+                    }
+                }
+                for type_param in &mut decl.type_parameters {
+                    if let Some(type_id) = self.find_match(type_param.type_id, engines) {
+                        need_to_create_new = true;
+                        type_param.type_id = type_id;
+                    }
+                }
+                if need_to_create_new {
+                    let new_decl_ref =
+                        decl_engine.insert(decl, decl_engine.get_parsed_decl_id(&decl_id).as_ref());
+                    Some(type_engine.insert(
+                        engines,
+                        TypeInfo::Struct(*new_decl_ref.id()),
                         new_decl_ref.decl_span().source_id(),
                     ))
                 } else {
                     None
                 }
             }
-            TypeInfo::Enum(decl_ref) => {
-                let mut decl = (*decl_engine.get_enum(&decl_ref)).clone();
+            TypeInfo::Enum(decl_id) => {
+                let mut decl = (*decl_engine.get_enum(&decl_id)).clone();
                 let mut need_to_create_new = false;
 
                 for variant in &mut decl.variants {
@@ -386,10 +467,11 @@ impl TypeSubstMap {
                     }
                 }
                 if need_to_create_new {
-                    let new_decl_ref = decl_engine.insert(decl);
+                    let new_decl_ref =
+                        decl_engine.insert(decl, decl_engine.get_parsed_decl_id(&decl_id).as_ref());
                     Some(type_engine.insert(
                         engines,
-                        TypeInfo::Enum(new_decl_ref.clone()),
+                        TypeInfo::Enum(*new_decl_ref.id()),
                         new_decl_ref.decl_span().source_id(),
                     ))
                 } else {
@@ -406,6 +488,15 @@ impl TypeSubstMap {
                     )
                 })
             }
+            TypeInfo::Slice(mut elem_ty) => {
+                let type_id = self.find_match(elem_ty.type_id, engines)?;
+                elem_ty.type_id = type_id;
+                Some(type_engine.insert(
+                    engines,
+                    TypeInfo::Slice(elem_ty.clone()),
+                    elem_ty.span.source_id(),
+                ))
+            }
             TypeInfo::Tuple(fields) => {
                 let mut need_to_create_new = false;
                 let mut source_id = None;
@@ -468,10 +559,6 @@ impl TypeSubstMap {
                 ty.type_id = type_id;
                 type_engine.insert(engines, TypeInfo::Ptr(ty.clone()), ty.span.source_id())
             }),
-            TypeInfo::Slice(mut ty) => self.find_match(ty.type_id, engines).map(|type_id| {
-                ty.type_id = type_id;
-                type_engine.insert(engines, TypeInfo::Slice(ty.clone()), ty.span.source_id())
-            }),
             TypeInfo::TraitType { .. } => iter_for_match(engines, self, &type_info),
             TypeInfo::Ref {
                 to_mutable_value,
@@ -510,13 +597,34 @@ fn iter_for_match(
     type_info: &TypeInfo,
 ) -> Option<TypeId> {
     let type_engine = engines.te();
+
     for (source_type, dest_type) in &type_mapping.mapping {
-        if type_engine
-            .get(*source_type)
-            .eq(type_info, &PartialEqWithEnginesContext::new(engines))
+        let source_type_info = type_engine.get(*source_type);
+
+        // Allows current placeholder(T:T1+T2) to match source placeholder(T:T1)
+        if let (
+            TypeInfo::Placeholder(source_type_param),
+            TypeInfo::Placeholder(current_type_param),
+        ) = ((*source_type_info).clone(), type_info)
         {
+            if source_type_param.name_ident.as_str() == current_type_param.name_ident.as_str()
+                && current_type_param
+                    .trait_constraints
+                    .iter()
+                    .all(|current_tc| {
+                        source_type_param.trait_constraints.iter().any(|source_tc| {
+                            source_tc.eq(current_tc, &PartialEqWithEnginesContext::new(engines))
+                        })
+                    })
+            {
+                return Some(*dest_type);
+            }
+        }
+
+        if source_type_info.eq(type_info, &PartialEqWithEnginesContext::new(engines)) {
             return Some(*dest_type);
         }
     }
+
     None
 }
diff --git a/sway-core/src/type_system/substitute/subst_types.rs b/sway-core/src/type_system/substitute/subst_types.rs
index 9d61fe3a63c..f5107ebd59a 100644
--- a/sway-core/src/type_system/substitute/subst_types.rs
+++ b/sway-core/src/type_system/substitute/subst_types.rs
@@ -24,43 +24,60 @@ impl std::ops::BitOr for HasChanges {
     }
 }
 
+pub struct SubstTypesContext<'a, 'b> {
+    pub engines: &'a Engines,
+    pub type_subst_map: &'b TypeSubstMap,
+    pub subst_function_body: bool,
+}
+
+impl<'a, 'b> SubstTypesContext<'a, 'b> {
+    pub fn new(
+        engines: &'a Engines,
+        type_subst_map: &'b TypeSubstMap,
+        subst_function_body: bool,
+    ) -> SubstTypesContext<'a, 'b> {
+        SubstTypesContext {
+            engines,
+            type_subst_map,
+            subst_function_body,
+        }
+    }
+}
+
 pub trait SubstTypes {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges;
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges;
 
-    fn subst(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        if type_mapping.is_empty() {
+    fn subst(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        if ctx.type_subst_map.is_empty() {
             HasChanges::No
         } else {
-            self.subst_inner(type_mapping, engines)
+            self.subst_inner(ctx)
         }
     }
 }
 
 impl<A, B: SubstTypes> SubstTypes for (A, B) {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.1.subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.1.subst(ctx)
     }
 }
 
 impl<T: SubstTypes> SubstTypes for Box<T> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.as_mut().subst(type_mapping, engines)
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.as_mut().subst(ctx)
     }
 }
 
 impl<T: SubstTypes> SubstTypes for Option<T> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.as_mut()
-            .map(|x| x.subst(type_mapping, engines))
-            .unwrap_or_default()
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.as_mut().map(|x| x.subst(ctx)).unwrap_or_default()
     }
 }
 
 impl<T: SubstTypes> SubstTypes for Vec<T> {
-    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
-        self.iter_mut().fold(HasChanges::No, |has_change, x| {
-            x.subst(type_mapping, engines) | has_change
-        })
+    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
+        self.iter_mut()
+            .fold(HasChanges::No, |has_change, x| x.subst(ctx) | has_change)
     }
 }
 
diff --git a/sway-core/src/type_system/unify/unifier.rs b/sway-core/src/type_system/unify/unifier.rs
index 0efc7883153..41b72802602 100644
--- a/sway-core/src/type_system/unify/unifier.rs
+++ b/sway-core/src/type_system/unify/unifier.rs
@@ -6,11 +6,12 @@ use sway_types::Span;
 use crate::{
     engine_threading::{Engines, PartialEqWithEngines, PartialEqWithEnginesContext, WithEngines},
     language::{ty, CallPath},
-    type_system::priv_prelude::*,
+    type_system::{engine::Unification, priv_prelude::*},
 };
 
 use super::occurs_check::OccursCheck;
 
+#[derive(Debug, Clone)]
 pub(crate) enum UnifyKind {
     /// Make the types of `received` and `expected` equivalent (or produce an
     /// error if there is a conflict between them).
@@ -63,6 +64,7 @@ impl<'a> Unifier<'a> {
         let type_engine = self.engines.te();
         let source_id = span.source_id().copied();
         type_engine.replace(
+            self.engines,
             received,
             TypeSourceInfo {
                 type_info: expected_type_info.clone().into(),
@@ -81,6 +83,7 @@ impl<'a> Unifier<'a> {
         let type_engine = self.engines.te();
         let source_id = span.source_id().copied();
         type_engine.replace(
+            self.engines,
             expected,
             TypeSourceInfo {
                 type_info: received_type_info.clone().into(),
@@ -90,11 +93,30 @@ impl<'a> Unifier<'a> {
     }
 
     /// Performs type unification with `received` and `expected`.
-    pub(crate) fn unify(&self, handler: &Handler, received: TypeId, expected: TypeId, span: &Span) {
+    pub(crate) fn unify(
+        &self,
+        handler: &Handler,
+        received: TypeId,
+        expected: TypeId,
+        span: &Span,
+        push_unification: bool,
+    ) {
+        if push_unification {
+            let unification = Unification {
+                received,
+                expected,
+                span: span.clone(),
+                help_text: self.help_text.clone(),
+                unify_kind: self.unify_kind.clone(),
+            };
+
+            self.engines.te().push_unification(unification);
+        }
+
         use TypeInfo::{
             Alias, Array, Boolean, Contract, Enum, Never, Numeric, Placeholder, RawUntypedPtr,
-            RawUntypedSlice, Ref, StringArray, StringSlice, Struct, Tuple, Unknown, UnknownGeneric,
-            UnsignedInteger, B256,
+            RawUntypedSlice, Ref, Slice, StringArray, StringSlice, Struct, Tuple, Unknown,
+            UnknownGeneric, UnsignedInteger, B256,
         };
 
         if received == expected {
@@ -123,6 +145,9 @@ impl<'a> Unifier<'a> {
             (Array(re, rc), Array(ee, ec)) if rc.val() == ec.val() => {
                 self.unify_type_arguments_in_parents(handler, received, expected, span, re, ee);
             }
+            (Slice(re), Slice(ee)) => {
+                self.unify_type_arguments_in_parents(handler, received, expected, span, re, ee);
+            }
             (Struct(r_decl_ref), Struct(e_decl_ref)) => {
                 let r_decl = self.engines.de().get_struct(r_decl_ref);
                 let e_decl = self.engines.de().get_struct(e_decl_ref);
@@ -221,8 +246,8 @@ impl<'a> Unifier<'a> {
             (Never, _) => {}
 
             // Type aliases and the types they encapsulate coerce to each other.
-            (Alias { ty, .. }, _) => self.unify(handler, ty.type_id, expected, span),
-            (_, Alias { ty, .. }) => self.unify(handler, received, ty.type_id, span),
+            (Alias { ty, .. }, _) => self.unify(handler, ty.type_id, expected, span, false),
+            (_, Alias { ty, .. }) => self.unify(handler, received, ty.type_id, span, false),
 
             (Enum(r_decl_ref), Enum(e_decl_ref)) => {
                 let r_decl = self.engines.de().get_enum(r_decl_ref);
@@ -324,7 +349,6 @@ impl<'a> Unifier<'a> {
                         received,
                         help_text: self.help_text.clone(),
                         span: span.clone(),
-                        internal: "4".into(),
                     }
                     .into(),
                 );
@@ -353,7 +377,6 @@ impl<'a> Unifier<'a> {
                     received,
                     help_text: self.help_text.clone(),
                     span: span.clone(),
-                    internal: "3".into(),
                 }
                 .into(),
             );
@@ -362,7 +385,7 @@ impl<'a> Unifier<'a> {
 
     fn unify_tuples(&self, handler: &Handler, rfs: &[TypeArgument], efs: &[TypeArgument]) {
         for (rf, ef) in rfs.iter().zip(efs.iter()) {
-            self.unify(handler, rf.type_id, ef.type_id, &rf.span);
+            self.unify(handler, rf.type_id, ef.type_id, &rf.span, false);
         }
     }
 
@@ -384,10 +407,11 @@ impl<'a> Unifier<'a> {
                     rf.type_argument.type_id,
                     ef.type_argument.type_id,
                     span,
+                    false,
                 );
             });
             rtps.iter().zip(etps.iter()).for_each(|(rtp, etp)| {
-                self.unify(handler, rtp.type_id, etp.type_id, span);
+                self.unify(handler, rtp.type_id, etp.type_id, span, false);
             });
         } else {
             let (received, expected) = self.assign_args(received, expected);
@@ -397,7 +421,6 @@ impl<'a> Unifier<'a> {
                     received,
                     help_text: self.help_text.clone(),
                     span: span.clone(),
-                    internal: "2".into(),
                 }
                 .into(),
             );
@@ -422,13 +445,13 @@ impl<'a> Unifier<'a> {
                     rv.type_argument.type_id,
                     ev.type_argument.type_id,
                     span,
+                    false,
                 );
             });
             rtps.iter().zip(etps.iter()).for_each(|(rtp, etp)| {
-                self.unify(handler, rtp.type_id, etp.type_id, span);
+                self.unify(handler, rtp.type_id, etp.type_id, span, false);
             });
         } else {
-            let internal = format!("[{received:?}] versus [{expected:?}]");
             let (received, expected) = self.assign_args(received, expected);
             handler.emit_err(
                 TypeError::MismatchedType {
@@ -436,7 +459,6 @@ impl<'a> Unifier<'a> {
                     received,
                     help_text: self.help_text.clone(),
                     span: span.clone(),
-                    internal,
                 }
                 .into(),
             );
@@ -462,6 +484,7 @@ impl<'a> Unifier<'a> {
             received_type_argument.type_id,
             expected_type_argument.type_id,
             span,
+            false,
         );
         let (new_errors, warnings) = h.consume();
 
@@ -475,7 +498,6 @@ impl<'a> Unifier<'a> {
                     received,
                     help_text: self.help_text.clone(),
                     span: span.clone(),
-                    internal: "1".into(),
                 }
                 .into(),
             );
diff --git a/sway-core/src/type_system/unify/unify_check.rs b/sway-core/src/type_system/unify/unify_check.rs
index 24f73a077c1..7479a4142ac 100644
--- a/sway-core/src/type_system/unify/unify_check.rs
+++ b/sway-core/src/type_system/unify/unify_check.rs
@@ -224,7 +224,8 @@ impl<'a> UnifyCheck<'a> {
     fn check_inner(&self, left: TypeId, right: TypeId) -> bool {
         use TypeInfo::{
             Alias, Array, ContractCaller, Custom, Enum, ErrorRecovery, Never, Numeric, Placeholder,
-            Ref, StringArray, StringSlice, Struct, Tuple, Unknown, UnknownGeneric, UnsignedInteger,
+            Ref, Slice, StringArray, StringSlice, Struct, Tuple, Unknown, UnknownGeneric,
+            UnsignedInteger,
         };
         use UnifyCheckMode::{
             Coercion, ConstraintSubset, NonDynamicEquality, NonGenericConstraintSubset,
@@ -242,10 +243,15 @@ impl<'a> UnifyCheck<'a> {
             (Never, Never) => {
                 return true;
             }
+
             (Array(l0, l1), Array(r0, r1)) => {
                 return self.check_inner(l0.type_id, r0.type_id) && l1.val() == r1.val();
             }
 
+            (Slice(l0), Slice(r0)) => {
+                return self.check_inner(l0.type_id, r0.type_id);
+            }
+
             (Tuple(l_types), Tuple(r_types)) => {
                 let l_types = l_types.iter().map(|x| x.type_id).collect::<Vec<_>>();
                 let r_types = r_types.iter().map(|x| x.type_id).collect::<Vec<_>>();
@@ -465,7 +471,10 @@ impl<'a> UnifyCheck<'a> {
                             parent: _,
                             is_from_type_parameter: _,
                         },
-                    ) => rtc.eq(ltc, &PartialEqWithEnginesContext::new(self.engines)),
+                    ) => {
+                        matches!(self.mode, NonGenericConstraintSubset)
+                            || rtc.eq(ltc, &PartialEqWithEnginesContext::new(self.engines))
+                    }
 
                     // any type can be coerced into a generic,
                     // except if the type already contains the generic
diff --git a/sway-core/src/types/mod.rs b/sway-core/src/types/mod.rs
index da142cd8ae4..6cf2ec6d39e 100644
--- a/sway-core/src/types/mod.rs
+++ b/sway-core/src/types/mod.rs
@@ -1,5 +1,3 @@
 mod collect_types_metadata;
-mod unconstrained_type_parameters;
 
 pub(crate) use collect_types_metadata::*;
-pub(crate) use unconstrained_type_parameters::*;
diff --git a/sway-core/src/types/unconstrained_type_parameters.rs b/sway-core/src/types/unconstrained_type_parameters.rs
deleted file mode 100644
index e49b8621e8d..00000000000
--- a/sway-core/src/types/unconstrained_type_parameters.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use crate::{Engines, TypeParameter};
-
-pub(crate) trait UnconstrainedTypeParameters {
-    fn type_parameter_is_unconstrained(
-        &self,
-        engines: &Engines,
-        type_parameter: &TypeParameter,
-    ) -> bool;
-
-    fn type_parameter_is_constrained(
-        &self,
-        engines: &Engines,
-        type_parameter: &TypeParameter,
-    ) -> bool {
-        !self.type_parameter_is_unconstrained(engines, type_parameter)
-    }
-
-    fn unconstrained_type_parameters<'a>(
-        &self,
-        engines: &Engines,
-        type_parameters: &'a [TypeParameter],
-    ) -> Vec<&'a TypeParameter> {
-        let mut unconstrained = vec![];
-        for type_param in type_parameters {
-            if self.type_parameter_is_unconstrained(engines, type_param) {
-                unconstrained.push(type_param);
-            }
-        }
-        unconstrained
-    }
-
-    fn constrained_type_parameters<'a>(
-        &self,
-        engines: &Engines,
-        type_parameters: &'a [TypeParameter],
-    ) -> Vec<&'a TypeParameter> {
-        let mut constrained = vec![];
-        for type_param in type_parameters {
-            if self.type_parameter_is_constrained(engines, type_param) {
-                constrained.push(type_param);
-            }
-        }
-        constrained
-    }
-}
diff --git a/sway-error/Cargo.toml b/sway-error/Cargo.toml
index 471357779f8..c8810d96b91 100644
--- a/sway-error/Cargo.toml
+++ b/sway-error/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-error"
-version = "0.60.0"
+version.workspace = true
 description = "Sway's error handling"
 authors.workspace = true
 edition.workspace = true
@@ -9,13 +9,14 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-either = "1.9.0"
-in_definite = "1.0.0"
-num-traits = "0.2.14"
-smallvec = "1.7"
-sway-types = { version = "0.60.0", path = "../sway-types" }
-thiserror = "1.0"
-uwuify = { version = "^0.2", optional = true }
+either.workspace = true
+in_definite.workspace = true
+num-traits.workspace = true
+smallvec.workspace = true
+strsim.workspace = true
+sway-types.workspace = true
+thiserror.workspace = true
+uwuify = { workspace = true, optional = true }
 
 [features]
 default = []
diff --git a/sway-error/src/convert_parse_tree_error.rs b/sway-error/src/convert_parse_tree_error.rs
index 559a42bf772..6c909e2016e 100644
--- a/sway-error/src/convert_parse_tree_error.rs
+++ b/sway-error/src/convert_parse_tree_error.rs
@@ -3,8 +3,6 @@ use thiserror::Error;
 
 #[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ConvertParseTreeError {
-    #[error("pub use imports are not supported")]
-    PubUseNotSupported { span: Span },
     #[error("Imports without items are not supported")]
     ImportsWithoutItemsNotSupported { span: Span },
     #[error("functions used in applications may not be arbitrary expressions")]
@@ -121,12 +119,13 @@ pub enum ConvertParseTreeError {
     ExpectedCfgProgramTypeArgValue { span: Span },
     #[error("Expected \"true\" or \"false\" for experimental_new_encoding")]
     ExpectedExperimentalNewEncodingArgValue { span: Span },
+    #[error("Unexpected attribute value: \"{value}\" for attribute: \"cfg\"")]
+    InvalidCfgArg { span: Span, value: String },
 }
 
 impl Spanned for ConvertParseTreeError {
     fn span(&self) -> Span {
         match self {
-            ConvertParseTreeError::PubUseNotSupported { span } => span.clone(),
             ConvertParseTreeError::ImportsWithoutItemsNotSupported { span } => span.clone(),
             ConvertParseTreeError::FunctionArbitraryExpression { span } => span.clone(),
             ConvertParseTreeError::GenericsNotSupportedHere { span } => span.clone(),
@@ -185,6 +184,7 @@ impl Spanned for ConvertParseTreeError {
             ConvertParseTreeError::InvalidCfgProgramTypeArgValue { span, .. } => span.clone(),
             ConvertParseTreeError::ExpectedCfgProgramTypeArgValue { span } => span.clone(),
             ConvertParseTreeError::ExpectedExperimentalNewEncodingArgValue { span } => span.clone(),
+            ConvertParseTreeError::InvalidCfgArg { span, .. } => span.clone(),
         }
     }
 }
diff --git a/sway-error/src/diagnostic.rs b/sway-error/src/diagnostic.rs
index d301bebffaa..ddfe86bfb92 100644
--- a/sway-error/src/diagnostic.rs
+++ b/sway-error/src/diagnostic.rs
@@ -307,24 +307,56 @@ impl Hint {
         }
     }
 
+    pub fn multi_info(source_engine: &SourceEngine, span: &Span, hints: Vec<String>) -> Vec<Self> {
+        hints
+            .into_iter()
+            .map(|hint| Self::info(source_engine, span.clone(), hint))
+            .collect()
+    }
+
     pub fn help(source_engine: &SourceEngine, span: Span, text: String) -> Self {
         Self {
             label: Label::help(source_engine, span, text),
         }
     }
 
+    pub fn multi_help(source_engine: &SourceEngine, span: &Span, hints: Vec<String>) -> Vec<Self> {
+        hints
+            .into_iter()
+            .map(|hint| Self::help(source_engine, span.clone(), hint))
+            .collect()
+    }
+
     pub fn warning(source_engine: &SourceEngine, span: Span, text: String) -> Self {
         Self {
             label: Label::warning(source_engine, span, text),
         }
     }
 
+    pub fn multi_warning(
+        source_engine: &SourceEngine,
+        span: &Span,
+        hints: Vec<String>,
+    ) -> Vec<Self> {
+        hints
+            .into_iter()
+            .map(|hint| Self::warning(source_engine, span.clone(), hint))
+            .collect()
+    }
+
     pub fn error(source_engine: &SourceEngine, span: Span, text: String) -> Self {
         Self {
             label: Label::error(source_engine, span, text),
         }
     }
 
+    pub fn multi_error(source_engine: &SourceEngine, span: &Span, hints: Vec<String>) -> Vec<Self> {
+        hints
+            .into_iter()
+            .map(|hint| Self::error(source_engine, span.clone(), hint))
+            .collect()
+    }
+
     /// A [Hint] that will never be displayed. Convenient when defining [Hint]s that
     /// are displayed only if a condition is met.
     pub fn none() -> Self {
diff --git a/sway-error/src/error.rs b/sway-error/src/error.rs
index 97a1a159e5a..20fc0e02235 100644
--- a/sway-error/src/error.rs
+++ b/sway-error/src/error.rs
@@ -12,6 +12,7 @@ use sway_types::style::to_snake_case;
 use sway_types::{BaseIdent, Ident, IdentUnique, SourceEngine, Span, Spanned};
 use thiserror::Error;
 
+use self::ShadowingSource::*;
 use self::StructFieldUsageContext::*;
 
 #[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
@@ -367,6 +368,8 @@ pub enum CompileError {
         struct_is_empty: bool,
         usage_context: StructFieldUsageContext,
     },
+    #[error("Field \"{field_name}\" has multiple definitions.")]
+    StructFieldDuplicated { field_name: Ident, duplicate: Ident },
     #[error("No method named \"{method_name}\" found for type \"{type_name}\".")]
     MethodNotFound {
         method_name: Ident,
@@ -654,8 +657,12 @@ pub enum CompileError {
     ContractStorageFromExternalContext { span: Span },
     #[error("The {opcode} opcode cannot be used in a predicate.")]
     InvalidOpcodeFromPredicate { opcode: String, span: Span },
-    #[error("Array index out of bounds; the length is {count} but the index is {index}.")]
+    #[error("Index out of bounds; the length is {count} but the index is {index}.")]
     ArrayOutOfBounds { index: u64, count: u64, span: Span },
+    #[error(
+        "Invalid range; the range end at index {end} is smaller than its start at index {start}"
+    )]
+    InvalidRangeEndGreaterThanStart { start: u64, end: u64, span: Span },
     #[error("Tuple index {index} is out of bounds. The tuple has {count} element{}.", plural_s(*count))]
     TupleIndexOutOfBounds {
         index: usize,
@@ -664,20 +671,58 @@ pub enum CompileError {
         span: Span,
         prefix_span: Span,
     },
-    #[error("Constants cannot be shadowed. {variable_or_constant} \"{name}\" shadows constant with the same name.")]
+    #[error("Constants cannot be shadowed. {shadowing_source} \"{name}\" shadows constant of the same name.")]
     ConstantsCannotBeShadowed {
-        variable_or_constant: String,
+        /// Defines what shadows the constant.
+        ///
+        /// Although being ready in the diagnostic, the `PatternMatchingStructFieldVar` option
+        /// is currently not used. Getting the information about imports and aliases while
+        /// type checking match branches is too much effort at the moment, compared to gained
+        /// additional clarity of the error message. We might add support for this option in
+        /// the future.
+        shadowing_source: ShadowingSource,
         name: IdentUnique,
         constant_span: Span,
-        constant_decl: Span,
+        constant_decl_span: Span,
         is_alias: bool,
     },
-    #[error("Constants cannot shadow variables. The constant \"{name}\" shadows variable with the same name.")]
+    #[error("Configurables cannot be shadowed. {shadowing_source} \"{name}\" shadows configurable of the same name.")]
+    ConfigurablesCannotBeShadowed {
+        /// Defines what shadows the configurable.
+        ///
+        /// Using configurable in pattern matching, expecting to behave same as a constant,
+        /// will result in [CompileError::ConfigurablesCannotBeMatchedAgainst].
+        /// Otherwise, we would end up with a very confusing error message that
+        /// a configurable cannot be shadowed by a variable.
+        /// In the, unlikely but equally confusing, case of a struct field pattern variable
+        /// named same as the configurable we also want to provide a better explanation
+        /// and `shadowing_source` helps us distinguish that case as well.
+        shadowing_source: ShadowingSource,
+        name: IdentUnique,
+        configurable_span: Span,
+    },
+    #[error("Configurables cannot be matched against. Configurable \"{name}\" cannot be used in pattern matching.")]
+    ConfigurablesCannotBeMatchedAgainst {
+        name: IdentUnique,
+        configurable_span: Span,
+    },
+    #[error(
+        "Constants cannot shadow variables. Constant \"{name}\" shadows variable of the same name."
+    )]
     ConstantShadowsVariable {
         name: IdentUnique,
         variable_span: Span,
     },
-    #[error("The imported symbol \"{name}\" shadows another symbol with the same name.")]
+    #[error("{existing_constant_or_configurable} of the name \"{name}\" already exists.")]
+    ConstantDuplicatesConstantOrConfigurable {
+        /// Text "Constant" or "Configurable". Denotes already declared constant or configurable.
+        existing_constant_or_configurable: &'static str,
+        /// Text "Constant" or "Configurable". Denotes constant or configurable attempted to be declared.
+        new_constant_or_configurable: &'static str,
+        name: IdentUnique,
+        existing_span: Span,
+    },
+    #[error("Imported symbol \"{name}\" shadows another symbol of the same name.")]
     ShadowsOtherSymbol { name: IdentUnique },
     #[error("The name \"{name}\" is already used for a generic parameter in this scope.")]
     GenericShadowsGeneric { name: IdentUnique },
@@ -736,11 +781,6 @@ pub enum CompileError {
         supported_types_message: Vec<&'static str>,
         span: Span,
     },
-    #[error(
-        "Storage attribute access mismatch. Try giving the surrounding function more access by \
-        adding \"#[{STORAGE_PURITY_ATTRIBUTE_NAME}({attrs})]\" to the function declaration."
-    )]
-    StorageAccessMismatch { attrs: String, span: Span },
     #[error(
         "The function \"{fn_name}\" in {interface_name} is pure, but this \
         implementation is not.  The \"{STORAGE_PURITY_ATTRIBUTE_NAME}\" annotation must be \
@@ -766,13 +806,17 @@ pub enum CompileError {
     #[error("Impure function inside of non-contract. Contract storage is only accessible from contracts.")]
     ImpureInNonContract { span: Span },
     #[error(
-        "This function performs a storage {storage_op} but does not have the required \
-        attribute(s).  Try adding \"#[{STORAGE_PURITY_ATTRIBUTE_NAME}({attrs})]\" to the function \
+        "This function performs storage access but does not have the required storage \
+        attribute(s). Try adding \"#[{STORAGE_PURITY_ATTRIBUTE_NAME}({suggested_attributes})]\" to the function \
         declaration."
     )]
-    ImpureInPureContext {
-        storage_op: &'static str,
-        attrs: String,
+    StorageAccessMismatched {
+        /// True if the function with mismatched access is pure.
+        is_pure: bool,
+        storage_access_violations: Vec<(Span, StorageAccess)>,
+        suggested_attributes: String,
+        /// Span pointing to the name of the function in the function declaration,
+        /// whose storage attributes mismatch the storage access patterns.
         span: Span,
     },
     #[error(
@@ -808,7 +852,7 @@ pub enum CompileError {
     #[error("Storage field \"{field_name}\" does not exist.")]
     StorageFieldDoesNotExist {
         field_name: IdentUnique,
-        available_fields: Vec<Ident>,
+        available_fields: Vec<(Vec<Ident>, Ident)>,
         storage_decl_span: Span,
     },
     #[error("No storage has been declared")]
@@ -928,7 +972,7 @@ pub enum CompileError {
     NonStrGenericType { span: Span },
     #[error("A contract method cannot call methods belonging to the same ABI")]
     ContractCallsItsOwnMethod { span: Span },
-    #[error("ABI cannot define a method with the same name as its super-ABI \"{superabi}\"")]
+    #[error("ABI cannot define a method of the same name as its super-ABI \"{superabi}\"")]
     AbiShadowsSuperAbiMethod { span: Span, superabi: Ident },
     #[error("ABI cannot inherit samely named method (\"{method_name}\") from several super-ABIs: \"{superabi1}\" and \"{superabi2}\"")]
     ConflictingSuperAbiMethods {
@@ -964,6 +1008,24 @@ pub enum CompileError {
     CouldNotGenerateEntryMissingImpl { ty: String, span: Span },
     #[error("Only bool, u8, u16, u32, u64, u256, b256, string arrays and string slices can be used here.")]
     EncodingUnsupportedType { span: Span },
+    #[error("Configurables need a function named \"abi_decode_in_place\" to be in scope.")]
+    ConfigurableMissingAbiDecodeInPlace { span: Span },
+    #[error("Collision detected between two different types.\n  Shared hash:{hash}\n  First type:{first_type}\n  Second type:{second_type}")]
+    ABIHashCollision {
+        span: Span,
+        hash: String,
+        first_type: String,
+        second_type: String,
+    },
+    #[error("Type must be known at this point")]
+    TypeMustBeKnownAtThisPoint { span: Span, internal: String },
+    #[error("Multiple impls satisfying trait for type.")]
+    MultipleImplsSatisfyingTraitForType {
+        span: Span,
+        type_annotation: String,
+        trait_names: Vec<String>,
+        trait_types_and_names: Vec<(String, String)>,
+    },
 }
 
 impl std::convert::From<TypeError> for CompileError {
@@ -1024,6 +1086,7 @@ impl Spanned for CompileError {
             StructCannotBeInstantiated { span, .. } => span.clone(),
             StructFieldIsPrivate { field_name, .. } => field_name.span(),
             StructFieldDoesNotExist { field_name, .. } => field_name.span(),
+            StructFieldDuplicated { field_name, .. } => field_name.span(),
             MethodNotFound { span, .. } => span.clone(),
             ModuleNotFound { span, .. } => span.clone(),
             TupleElementAccessOnNonTuple { span, .. } => span.clone(),
@@ -1092,7 +1155,10 @@ impl Spanned for CompileError {
             InvalidOpcodeFromPredicate { span, .. } => span.clone(),
             ArrayOutOfBounds { span, .. } => span.clone(),
             ConstantsCannotBeShadowed { name, .. } => name.span(),
+            ConfigurablesCannotBeShadowed { name, .. } => name.span(),
+            ConfigurablesCannotBeMatchedAgainst { name, .. } => name.span(),
             ConstantShadowsVariable { name, .. } => name.span(),
+            ConstantDuplicatesConstantOrConfigurable { name, .. } => name.span(),
             ShadowsOtherSymbol { name } => name.span(),
             GenericShadowsGeneric { name } => name.span(),
             MatchExpressionNonExhaustive { span, .. } => span.clone(),
@@ -1102,7 +1168,6 @@ impl Spanned for CompileError {
             MatchArmVariableMismatchedType { variable, .. } => variable.span(),
             MatchedValueIsNotValid { span, .. } => span.clone(),
             NotAnEnum { span, .. } => span.clone(),
-            StorageAccessMismatch { span, .. } => span.clone(),
             TraitDeclPureImplImpure { span, .. } => span.clone(),
             TraitImplPurityMismatch { span, .. } => span.clone(),
             DeclIsNotAnEnum { span, .. } => span.clone(),
@@ -1117,7 +1182,7 @@ impl Spanned for CompileError {
             DeclIsNotAConstant { span, .. } => span.clone(),
             DeclIsNotATypeAlias { span, .. } => span.clone(),
             ImpureInNonContract { span, .. } => span.clone(),
-            ImpureInPureContext { span, .. } => span.clone(),
+            StorageAccessMismatched { span, .. } => span.clone(),
             ParameterRefMutabilityMismatch { span, .. } => span.clone(),
             IntegerTooLarge { span, .. } => span.clone(),
             IntegerTooSmall { span, .. } => span.clone(),
@@ -1175,6 +1240,11 @@ impl Spanned for CompileError {
             CouldNotGenerateEntryMissingImpl { span, .. } => span.clone(),
             CannotBeEvaluatedToConfigurableSizeUnknown { span } => span.clone(),
             EncodingUnsupportedType { span } => span.clone(),
+            ConfigurableMissingAbiDecodeInPlace { span } => span.clone(),
+            ABIHashCollision { span, .. } => span.clone(),
+            InvalidRangeEndGreaterThanStart { span, .. } => span.clone(),
+            TypeMustBeKnownAtThisPoint { span, .. } => span.clone(),
+            MultipleImplsSatisfyingTraitForType { span, .. } => span.clone(),
         }
     }
 }
@@ -1183,28 +1253,31 @@ impl Spanned for CompileError {
 // - Guide-level explanation: https://github.com/FuelLabs/sway-rfcs/blob/master/rfcs/0011-expressive-diagnostics.md#guide-level-explanation
 // - Wording guidelines: https://github.com/FuelLabs/sway-rfcs/blob/master/rfcs/0011-expressive-diagnostics.md#wording-guidelines
 // For concrete examples, look at the existing diagnostics.
+//
+// The issue and the hints are not displayed if set to `Span::dummy()`.
+//
+// NOTE: Issue level should actually be the part of the reason. But it would complicate handling of labels in the transitional
+//       period when we still have "old-style" diagnostics.
+//       Let's leave it like this. Refactoring currently doesn't pay off.
+//       And our #[error] macro will anyhow encapsulate it and ensure consistency.
 impl ToDiagnostic for CompileError {
     fn to_diagnostic(&self, source_engine: &SourceEngine) -> Diagnostic {
         let code = Code::semantic_analysis;
         use CompileError::*;
         match self {
-            ConstantsCannotBeShadowed { variable_or_constant, name, constant_span, constant_decl, is_alias } => Diagnostic {
+            ConstantsCannotBeShadowed { shadowing_source, name, constant_span, constant_decl_span, is_alias } => Diagnostic {
                 reason: Some(Reason::new(code(1), "Constants cannot be shadowed".to_string())),
-                // NOTE: Issue level should actually be the part of the reason. But it would complicate handling of labels in the transitional
-                //       period when we still have "old-style" diagnostics.
-                //       Let's leave it like this, refactoring at the moment does not pay of.
-                //       And our #[error] macro will anyhow encapsulate it and ensure consistency.
                 issue: Issue::error(
                     source_engine,
                     name.span(),
                     format!(
-                        // Variable "x" shadows constant with the same name
+                        // Variable "x" shadows constant with of same name.
                         //  or
-                        // Constant "x" shadows imported constant with the same name
+                        // Constant "x" shadows imported constant of the same name.
                         //  or
                         // ...
-                        "{variable_or_constant} \"{name}\" shadows {}constant of the same name.",
-                        if constant_decl.clone() != Span::dummy() { "imported " } else { "" }
+                        "{shadowing_source} \"{name}\" shadows {}constant of the same name.",
+                        if constant_decl_span.clone() != Span::dummy() { "imported " } else { "" }
                     )
                 ),
                 hints: vec![
@@ -1212,34 +1285,134 @@ impl ToDiagnostic for CompileError {
                         source_engine,
                         constant_span.clone(),
                         format!(
-                            // Constant "x" is declared here.
+                            // Shadowed constant "x" is declared here.
+                            //  or
+                            // Shadowed constant "x" gets imported here.
                             //  or
-                            // Constant "x" gets imported here.
+                            // ...
                             "Shadowed constant \"{name}\" {} here{}.",
-                            if constant_decl.clone() != Span::dummy() { "gets imported" } else { "is declared" },
+                            if constant_decl_span.clone() != Span::dummy() { "gets imported" } else { "is declared" },
                             if *is_alias { " as alias" } else { "" }
                         )
                     ),
-                    Hint::info( // Ignored if the constant_decl is Span::dummy().
+                    if matches!(shadowing_source, PatternMatchingStructFieldVar) {
+                        Hint::help(
+                            source_engine,
+                            name.span(),
+                            format!("\"{name}\" is a struct field that defines a pattern variable of the same name.")
+                        )
+                    } else {
+                        Hint::none()
+                    },
+                    Hint::info( // Ignored if the `constant_decl_span` is `Span::dummy()`.
                         source_engine,
-                        constant_decl.clone(),
+                        constant_decl_span.clone(),
                         format!("This is the original declaration of the imported constant \"{name}\".")
                     ),
                 ],
                 help: vec![
-                    format!("Unlike variables, constants cannot be shadowed by other constants or variables."),
-                    match (variable_or_constant.as_str(), constant_decl.clone() != Span::dummy()) {
-                        ("Variable", false) => format!("Consider renaming either the variable \"{name}\" or the constant \"{name}\"."),
-                        ("Constant", false) => "Consider renaming one of the constants.".to_string(),
-                        (variable_or_constant, true) => format!(
+                    "Unlike variables, constants cannot be shadowed by other constants or variables.".to_string(),
+                    match (shadowing_source, *constant_decl_span != Span::dummy()) {
+                        (LetVar | PatternMatchingStructFieldVar, false) => format!("Consider renaming either the {} \"{name}\" or the constant \"{name}\".", 
+                            format!("{shadowing_source}").to_lowercase(),
+                        ),
+                        (Const, false) => "Consider renaming one of the constants.".to_string(),
+                        (shadowing_source, true) => format!(
                             "Consider renaming the {} \"{name}\" or using {} for the imported constant.",
-                            variable_or_constant.to_lowercase(),
+                            format!("{shadowing_source}").to_lowercase(),
                             if *is_alias { "a different alias" } else { "an alias" }
                         ),
-                        _ => unreachable!("We can have only the listed combinations: variable/constant shadows a non imported/imported constant.")
+                    },
+                    if matches!(shadowing_source, PatternMatchingStructFieldVar) {
+                        format!("To rename the pattern variable use the `:`. E.g.: `{name}: some_other_name`.")
+                    } else {
+                        Diagnostic::help_none()
+                    }
+                ],
+            },
+            ConfigurablesCannotBeShadowed { shadowing_source, name, configurable_span } => Diagnostic {
+                reason: Some(Reason::new(code(1), "Configurables cannot be shadowed".to_string())),
+                issue: Issue::error(
+                    source_engine,
+                    name.span(),
+                    format!("{shadowing_source} \"{name}\" shadows configurable of the same name.")
+                ),
+                hints: vec![
+                    Hint::info(
+                        source_engine,
+                        configurable_span.clone(),
+                        format!("Shadowed configurable \"{name}\" is declared here.")
+                    ),
+                    if matches!(shadowing_source, PatternMatchingStructFieldVar) {
+                        Hint::help(
+                            source_engine,
+                            name.span(),
+                            format!("\"{name}\" is a struct field that defines a pattern variable of the same name.")
+                        )
+                    } else {
+                        Hint::none()
+                    },
+                ],
+                help: vec![
+                    "Unlike variables, configurables cannot be shadowed by constants or variables.".to_string(),
+                    format!(
+                        "Consider renaming either the {} \"{name}\" or the configurable \"{name}\".",
+                        format!("{shadowing_source}").to_lowercase()
+                    ),
+                    if matches!(shadowing_source, PatternMatchingStructFieldVar) {
+                        format!("To rename the pattern variable use the `:`. E.g.: `{name}: some_other_name`.")
+                    } else {
+                        Diagnostic::help_none()
                     }
                 ],
             },
+            ConfigurablesCannotBeMatchedAgainst { name, configurable_span } => Diagnostic {
+                reason: Some(Reason::new(code(1), "Configurables cannot be matched against".to_string())),
+                issue: Issue::error(
+                    source_engine,
+                    name.span(),
+                    format!("\"{name}\" is a configurable and configurables cannot be matched against.")
+                ),
+                hints: {
+                    let mut hints = vec![
+                        Hint::info(
+                            source_engine,
+                            configurable_span.clone(),
+                            format!("Configurable \"{name}\" is declared here.")
+                        ),
+                    ];
+
+                    hints.append(&mut Hint::multi_help(source_engine, &name.span(), vec![
+                        format!("Are you trying to define a pattern variable named \"{name}\"?"),
+                        format!("In that case, use some other name for the pattern variable,"),
+                        format!("or consider renaming the configurable \"{name}\"."),
+                    ]));
+
+                    hints
+                },
+                help: vec![
+                    "Unlike constants, configurables cannot be matched against in pattern matching.".to_string(),
+                    "That's not possible, because patterns to match against must be compile-time constants.".to_string(),
+                    "Configurables are run-time constants. Their values are defined during the deployment.".to_string(),
+                    Diagnostic::help_empty_line(),
+                    "To test against a configurable, consider:".to_string(),
+                    format!("{}- replacing the `match` expression with `if-else`s altogether.", Indent::Single),
+                    format!("{}- matching against a variable and comparing that variable afterwards with the configurable.", Indent::Single),
+                    format!("{}  E.g., instead of:", Indent::Single),
+                    Diagnostic::help_empty_line(),
+                    format!("{}  SomeStruct {{ x: A_CONFIGURABLE, y: 42 }} => {{", Indent::Double),
+                    format!("{}      do_something();", Indent::Double),
+                    format!("{}  }}", Indent::Double),
+                    Diagnostic::help_empty_line(),
+                    format!("{}  to have:", Indent::Single),
+                    Diagnostic::help_empty_line(),
+                    format!("{}  SomeStruct {{ x, y: 42 }} => {{", Indent::Double),
+                    format!("{}      if x == A_CONFIGURABLE {{", Indent::Double),
+                    format!("{}          do_something();", Indent::Double),
+                    format!("{}      }}", Indent::Double),
+                    format!("{}  }}", Indent::Double),
+                ],
+            },
             ConstantShadowsVariable { name , variable_span } => Diagnostic {
                 reason: Some(Reason::new(code(1), "Constants cannot shadow variables".to_string())),
                 issue: Issue::error(
@@ -1259,6 +1432,41 @@ impl ToDiagnostic for CompileError {
                     format!("Consider renaming either the variable or the constant."),
                 ],
             },
+            ConstantDuplicatesConstantOrConfigurable { existing_constant_or_configurable, new_constant_or_configurable, name, existing_span } => Diagnostic {
+                reason: Some(Reason::new(code(1), match (*existing_constant_or_configurable, *new_constant_or_configurable) {
+                    ("Constant", "Constant") => "Constant of the same name already exists".to_string(),
+                    ("Constant", "Configurable") => "Constant of the same name as configurable already exists".to_string(),
+                    ("Configurable", "Constant") => "Configurable of the same name as constant already exists".to_string(),
+                    _ => unreachable!("We can have only the listed combinations. Configurable duplicating configurable is not a valid combination.")
+                })),
+                issue: Issue::error(
+                    source_engine,
+                    name.span(),
+                    format!("{new_constant_or_configurable} \"{name}\" has the same name as an already declared {}.",
+                        existing_constant_or_configurable.to_lowercase()
+                    )
+                ),
+                hints: vec![
+                    Hint::info(
+                        source_engine,
+                        existing_span.clone(),
+                        format!("{existing_constant_or_configurable} \"{name}\" is {}declared here.",
+                            // If a constant clashes with an already declared constant.
+                            if existing_constant_or_configurable == new_constant_or_configurable {
+                                "already "
+                            } else {
+                                ""
+                            }
+                        )
+                    ),
+                ],
+                help: vec![
+                    match (*existing_constant_or_configurable, *new_constant_or_configurable) {
+                        ("Constant", "Constant") => "Consider renaming one of the constants, or in case of imported constants, using an alias.".to_string(),
+                        _ => "Consider renaming either the configurable or the constant, or in case of an imported constant, using an alias.".to_string(),
+                    },
+                ],
+            },
             MultipleDefinitionsOfMatchArmVariable { match_value, match_type, first_definition, first_definition_is_struct_field, duplicate, duplicate_is_struct_field } => Diagnostic {
                 reason: Some(Reason::new(code(1), "Match pattern variable is already defined".to_string())),
                 issue: Issue::error(
@@ -1870,6 +2078,24 @@ impl ToDiagnostic for CompileError {
                 },
                 help: vec![],
             },
+            StructFieldDuplicated { field_name, duplicate } => Diagnostic {
+                reason: Some(Reason::new(code(1), "Struct field has multiple definitions".to_string())),
+                issue: Issue::error(
+                    source_engine,
+                    field_name.span(),
+                    format!("Field \"{field_name}\" has multiple definitions.")
+                ),
+                hints: {
+                    vec![
+                        Hint::info(
+                            source_engine,
+                            duplicate.span(),
+                            "Field definition duplicated here.".into(),
+                        )
+                   ]
+                },
+                help: vec![],
+            },
             NotIndexable { actually, span } => Diagnostic {
                 reason: Some(Reason::new(code(1), "Type is not indexable".to_string())),
                 issue: Issue::error(
@@ -1944,9 +2170,17 @@ impl ToDiagnostic for CompileError {
                         ("The storage is empty. It doesn't have any fields.".to_string(), false)
                     } else {
                         const NUM_OF_FIELDS_TO_DISPLAY: usize = 4;
-                        match &available_fields[..] {
+                        let display_fields = available_fields.iter().map(|(path, field_name)| {
+                            let path = path.iter().map(ToString::to_string).collect::<Vec<_>>().join("::");
+                            if path.is_empty() {
+                                format!("storage.{field_name}")
+                            } else {
+                                format!("storage::{path}.{field_name}")
+                            }
+                        }).collect::<Vec<_>>();
+                        match &display_fields[..] {
                             [field] => (format!("Only available storage field is \"{field}\"."), false),
-                            _ => (format!("Available storage fields are {}.", sequence_to_str(available_fields, Enclosing::DoubleQuote, NUM_OF_FIELDS_TO_DISPLAY)),
+                            _ => (format!("Available storage fields are {}.", sequence_to_str(&display_fields, Enclosing::DoubleQuote, NUM_OF_FIELDS_TO_DISPLAY)),
                                     available_fields.len() > NUM_OF_FIELDS_TO_DISPLAY
                                 ),
                         }
@@ -2420,6 +2654,31 @@ impl ToDiagnostic for CompileError {
                             format!("{}  E.g., `*ref_to_mutable_value` or `*max_mut(&mut x, &mut y)`.", Indent::Single),
                         ]
                     },
+                    ParseErrorKind::UnrecognizedOpCode { known_op_codes } => Diagnostic {
+                        reason: Some(Reason::new(code(1), "Assembly instruction is unknown".to_string())),
+                        issue: Issue::error(
+                            source_engine,
+                            error.span.clone(),
+                            format!("\"{}\" is not a known assembly instruction.",
+                                error.span.as_str()
+                            )
+                        ),
+                        hints: {
+                            let suggestions = &did_you_mean(error.span.as_str(), known_op_codes.iter(), 2);
+                            if suggestions.is_empty() {
+                                vec![]
+                            } else {
+                                vec![
+                                    Hint::help(
+                                        source_engine,
+                                        error.span.clone(),
+                                        format!("Did you mean {}?", sequence_to_str_or(suggestions, Enclosing::DoubleQuote, 2))
+                                    ),
+                                ]
+                            }
+                        },
+                        help: vec![]
+                    },
                     _ => Diagnostic {
                                 // TODO: Temporary we use self here to achieve backward compatibility.
                                 //       In general, self must not be used and will not be used once we
@@ -2430,6 +2689,85 @@ impl ToDiagnostic for CompileError {
                         },
                 }
             },
+            ConfigurableMissingAbiDecodeInPlace { span } => Diagnostic {
+                reason: Some(Reason::new(code(1), "Configurables need a function named \"abi_decode_in_place\" to be in scope".to_string())),
+                issue: Issue::error(
+                    source_engine,
+                    span.clone(),
+                    String::new()
+                ),
+                hints: vec![],
+                help: vec![
+                    "The function \"abi_decode_in_place\" is usually defined in the standard library module \"core::codec\".".into(),
+                    "Verify that you are using a version of the \"core\" standard library that contains this function.".into(),
+                ],
+            },
+            StorageAccessMismatched { span, is_pure, suggested_attributes, storage_access_violations } => Diagnostic {
+                // Pure function cannot access storage
+                //   or
+                // Storage read-only function cannot write to storage
+                reason: Some(Reason::new(code(1), format!("{} function cannot {} storage",
+                    if *is_pure {
+                        "Pure"
+                    } else {
+                        "Storage read-only"
+                    },
+                    if *is_pure {
+                        "access"
+                    } else {
+                        "write to"
+                    }
+                ))),
+                issue: Issue::error(
+                    source_engine,
+                    span.clone(),
+                    format!("Function \"{}\" is {} and cannot {} storage.",
+                        span.as_str(),
+                        if *is_pure {
+                            "pure"
+                        } else {
+                            "declared as `#[storage(read)]`"
+                        },
+                        if *is_pure {
+                            "access"
+                        } else {
+                            "write to"
+                        },
+                    )
+                ),
+                hints: storage_access_violations
+                    .iter()
+                    .map(|(span, storage_access)| Hint::info(
+                        source_engine,
+                        span.clone(),
+                        format!("{storage_access}")
+                    ))
+                    .collect(),
+                help: vec![
+                    format!("Consider declaring the function \"{}\" as `#[{STORAGE_PURITY_ATTRIBUTE_NAME}({suggested_attributes})]`,",
+                        span.as_str()
+                    ),
+                    format!("or removing the {} from the function body.",
+                        if *is_pure {
+                            "storage access code".to_string()
+                        } else {
+                            format!("storage write{}", plural_s(storage_access_violations.len()))
+                        }
+                    ),
+                ],
+            },
+            MultipleImplsSatisfyingTraitForType { span, type_annotation , trait_names, trait_types_and_names: trait_types_and_spans } => Diagnostic {
+                reason: Some(Reason::new(code(1), format!("Multiple impls satisfying {} for {}", trait_names.join("+"), type_annotation))),
+                issue: Issue::error(
+                    source_engine,
+                    span.clone(),
+                    String::new()
+                ),
+                hints: vec![],
+                help: vec![format!("Trait{} implemented for types:\n{}", if trait_names.len() > 1 {"s"} else {""}, trait_types_and_spans.iter().enumerate().map(|(e, (type_id, name))| 
+                    format!("#{} {} for {}", e, name, type_id.clone())
+                ).collect::<Vec<_>>().join("\n"))],
+            },
            _ => Diagnostic {
                     // TODO: Temporary we use self here to achieve backward compatibility.
                     //       In general, self must not be used and will not be used once we
@@ -2464,6 +2802,9 @@ pub enum TypeNotAllowedReason {
 
     #[error("`str` or a type containing `str` on `const` is not allowed.")]
     StringSliceInConst,
+
+    #[error("slices or types containing slices on `const` are not allowed.")]
+    SliceInConst,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -2489,9 +2830,81 @@ pub enum InvalidImplementingForType {
 impl fmt::Display for InvalidImplementingForType {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            InvalidImplementingForType::SelfType => f.write_str("\"Self\""),
-            InvalidImplementingForType::Placeholder => f.write_str("Placeholder `_`"),
-            InvalidImplementingForType::Other => f.write_str("This"),
+            Self::SelfType => f.write_str("\"Self\""),
+            Self::Placeholder => f.write_str("Placeholder `_`"),
+            Self::Other => f.write_str("This"),
+        }
+    }
+}
+
+/// Defines what shadows a constant or a configurable.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ShadowingSource {
+    /// A constant or a configurable is shadowed by a constant.
+    Const,
+    /// A constant or a configurable is shadowed by a local variable declared with the `let` keyword.
+    LetVar,
+    /// A constant or a configurable is shadowed by a variable declared in pattern matching,
+    /// being a struct field. E.g., `S { some_field }`.
+    PatternMatchingStructFieldVar,
+}
+
+impl fmt::Display for ShadowingSource {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Const => f.write_str("Constant"),
+            Self::LetVar => f.write_str("Variable"),
+            Self::PatternMatchingStructFieldVar => f.write_str("Pattern variable"),
+        }
+    }
+}
+
+/// Defines how a storage gets accessed within a function body.
+/// E.g., calling `__state_clear` intrinsic or using `scwq` ASM instruction
+/// represent a [StorageAccess::Clear] access.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum StorageAccess {
+    Clear,
+    ReadWord,
+    ReadSlots,
+    WriteWord,
+    WriteSlots,
+    /// Storage access happens via call to an impure function.
+    /// The parameters are the call path span and if the called function
+    /// reads from and writes to the storage: (call_path, reads, writes).
+    ImpureFunctionCall(Span, bool, bool),
+}
+
+impl StorageAccess {
+    pub fn is_write(&self) -> bool {
+        matches!(
+            self,
+            Self::Clear | Self::WriteWord | Self::WriteSlots | Self::ImpureFunctionCall(_, _, true)
+        )
+    }
+}
+
+impl fmt::Display for StorageAccess {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Clear => f.write_str("Clearing the storage happens here."),
+            Self::ReadWord => f.write_str("Reading a word from the storage happens here."),
+            Self::ReadSlots => f.write_str("Reading storage slots happens here."),
+            Self::WriteWord => f.write_str("Writing a word to the storage happens here."),
+            Self::WriteSlots => f.write_str("Writing to storage slots happens here."),
+            Self::ImpureFunctionCall(call_path, reads, writes) => f.write_fmt(format_args!(
+                "Function \"{}\" {} the storage.",
+                call_path_suffix_with_args(&call_path.as_str().to_string()),
+                match (reads, writes) {
+                    (true, true) => "reads from and writes to",
+                    (true, false) => "reads from",
+                    (false, true) => "writes to",
+                    (false, false) => unreachable!(
+                        "Function \"{}\" is impure, so it must read from or write to the storage.",
+                        call_path.as_str()
+                    ),
+                }
+            )),
         }
     }
 }
diff --git a/sway-error/src/formatting.rs b/sway-error/src/formatting.rs
index 84adf117f4f..b4483424d6d 100644
--- a/sway-error/src/formatting.rs
+++ b/sway-error/src/formatting.rs
@@ -3,7 +3,7 @@
 
 use std::{
     borrow::Cow,
-    cmp,
+    cmp::{self, Ordering},
     fmt::{self, Display},
 };
 
@@ -95,6 +95,42 @@ impl Display for Indent {
 ///
 /// Panics if the `sequence` is empty, or `max_items` is zero.
 pub(crate) fn sequence_to_str<T>(sequence: &[T], enclosing: Enclosing, max_items: usize) -> String
+where
+    T: Display,
+{
+    sequence_to_str_impl(sequence, enclosing, max_items, "and")
+}
+
+/// Returns reading-friendly textual representation of the `sequence`, with comma-separated
+/// items and each item optionally enclosed in the specified `enclosing`.
+/// If the sequence has more than `max_items` the remaining items are replaced
+/// with the text "or <number> more".
+///
+/// E.g.:
+/// [a] => "a"
+/// [a, b] => "a" or "b"
+/// [a, b, c] => "a", "b" or "c"
+/// [a, b, c, d] => "a", "b", "c" or one more
+/// [a, b, c, d, e] => "a", "b", "c" or two more
+///
+/// Panics if the `sequence` is empty, or `max_items` is zero.
+pub(crate) fn sequence_to_str_or<T>(
+    sequence: &[T],
+    enclosing: Enclosing,
+    max_items: usize,
+) -> String
+where
+    T: Display,
+{
+    sequence_to_str_impl(sequence, enclosing, max_items, "or")
+}
+
+fn sequence_to_str_impl<T>(
+    sequence: &[T],
+    enclosing: Enclosing,
+    max_items: usize,
+    and_or: &str,
+) -> String
 where
     T: Display,
 {
@@ -115,12 +151,13 @@ where
 
     if !remaining.is_empty() {
         format!(
-            "{}, and {} more",
+            "{}, {} {} more",
             to_display
                 .iter()
                 .map(fmt_item)
                 .collect::<Vec<_>>()
                 .join(", "),
+            and_or,
             number_to_str(remaining.len())
         )
     } else {
@@ -128,10 +165,15 @@ where
             [] => unreachable!("There must be at least one item in the sequence."),
             [item] => fmt_item(item),
             [first_item, second_item] => {
-                format!("{} and {}", fmt_item(first_item), fmt_item(second_item))
+                format!(
+                    "{} {} {}",
+                    fmt_item(first_item),
+                    and_or,
+                    fmt_item(second_item)
+                )
             }
             _ => format!(
-                "{}, and {}",
+                "{}, {} {}",
                 to_display
                     .split_last()
                     .unwrap()
@@ -140,6 +182,7 @@ where
                     .map(fmt_item)
                     .collect::<Vec::<_>>()
                     .join(", "),
+                and_or,
                 fmt_item(to_display.last().unwrap())
             ),
         }
@@ -152,15 +195,15 @@ where
 /// with the text "and <number> more".
 ///
 /// E.g.:
-/// [a] =>
-///   - a
-/// [a, b] =>
-///   - a
-///   - b
-/// [a, b, c, d, e] =>
-///   - a
-///   - b
-///   - and three more
+/// * [a] =>
+///     - a
+/// * [a, b] =>
+///     - a
+///     - b
+/// * [a, b, c, d, e] =>
+///     - a
+///     - b
+///     - and three more
 ///
 /// Panics if the `sequence` is empty, or `max_items` is zero.
 pub(crate) fn sequence_to_list<T>(sequence: &[T], indent: Indent, max_items: usize) -> Vec<String>
@@ -290,3 +333,32 @@ pub(crate) fn first_line(text: &str, with_ellipses: bool) -> Cow<str> {
         Cow::Owned(text[..index_of_new_line].to_string() + if with_ellipses { "..." } else { "" })
     }
 }
+
+/// Finds strings from an iterable of `possible_values` similar to a given value `v`.
+/// Returns a vector of all possible values that exceed a similarity threshold,
+/// sorted by similarity (most similar comes first). The returned vector will have
+/// at most `max_num_of_suggestions` elements.
+///
+/// The implementation is taken and adapted from the [Clap project](https://github.com/clap-rs/clap/blob/50f7646cf72dd7d4e76d9284d76bdcdaceb7c049/clap_builder/src/parser/features/suggestions.rs#L11).
+pub(crate) fn did_you_mean<T, I>(
+    v: &str,
+    possible_values: I,
+    max_num_of_suggestions: usize,
+) -> Vec<String>
+where
+    T: AsRef<str>,
+    I: IntoIterator<Item = T>,
+{
+    let mut candidates: Vec<_> = possible_values
+        .into_iter()
+        .map(|pv| (strsim::jaro(v, pv.as_ref()), pv.as_ref().to_owned()))
+        // Confidence of 0.7 so that bar -> baz is suggested.
+        .filter(|(confidence, _)| *confidence > 0.7)
+        .collect();
+    candidates.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));
+    candidates
+        .into_iter()
+        .take(max_num_of_suggestions)
+        .map(|(_, pv)| pv)
+        .collect()
+}
diff --git a/sway-error/src/handler.rs b/sway-error/src/handler.rs
index a9485d89c9a..24d2222da1b 100644
--- a/sway-error/src/handler.rs
+++ b/sway-error/src/handler.rs
@@ -1,5 +1,4 @@
 use crate::{error::CompileError, warning::CompileWarning};
-use std::collections::HashMap;
 
 use core::cell::RefCell;
 
@@ -106,6 +105,25 @@ impl Handler {
     {
         self.inner.borrow_mut().errors.retain(f)
     }
+
+    // Map all errors from `other` into this handler. If any mapping returns `None` it is ignored. This
+    // method returns if any error was mapped or not.
+    pub fn map_and_emit_errors_from(
+        &self,
+        other: Handler,
+        mut f: impl FnMut(CompileError) -> Option<CompileError>,
+    ) -> Result<(), ErrorEmitted> {
+        let mut emitted = Ok(());
+
+        let (errs, _) = other.consume();
+        for err in errs {
+            if let Some(err) = (f)(err) {
+                emitted = Err(self.emit_err(err));
+            }
+        }
+
+        emitted
+    }
 }
 
 /// Proof that an error was emitted through a `Handler`.
@@ -119,37 +137,10 @@ pub struct ErrorEmitted {
 /// Stdlib dedup in Rust assumes sorted data for efficiency, but we don't want that.
 /// A hash set would also mess up the order, so this is just a brute force way of doing it
 /// with a vector.
-fn dedup_unsorted<T: PartialEq + std::hash::Hash>(mut data: Vec<T>) -> Vec<T> {
-    // TODO(Centril): Consider using `IndexSet` instead for readability.
-    use smallvec::SmallVec;
-    use std::collections::hash_map::{DefaultHasher, Entry};
-    use std::hash::Hasher;
-
-    let mut write_index = 0;
-    let mut indexes: HashMap<u64, SmallVec<[usize; 1]>> = HashMap::with_capacity(data.len());
-    for read_index in 0..data.len() {
-        let hash = {
-            let mut hasher = DefaultHasher::new();
-            data[read_index].hash(&mut hasher);
-            hasher.finish()
-        };
-        let index_vec = match indexes.entry(hash) {
-            Entry::Occupied(oe) => {
-                if oe
-                    .get()
-                    .iter()
-                    .any(|index| data[*index] == data[read_index])
-                {
-                    continue;
-                }
-                oe.into_mut()
-            }
-            Entry::Vacant(ve) => ve.insert(SmallVec::new()),
-        };
-        data.swap(write_index, read_index);
-        index_vec.push(write_index);
-        write_index += 1;
-    }
-    data.truncate(write_index);
+fn dedup_unsorted<T: PartialEq + std::hash::Hash + Clone + Eq>(mut data: Vec<T>) -> Vec<T> {
+    use std::collections::HashSet;
+
+    let mut seen = HashSet::new();
+    data.retain(|item| seen.insert(item.clone()));
     data
 }
diff --git a/sway-error/src/parser_error.rs b/sway-error/src/parser_error.rs
index 9f7d4e364f7..21e417801cf 100644
--- a/sway-error/src/parser_error.rs
+++ b/sway-error/src/parser_error.rs
@@ -12,8 +12,10 @@ pub enum ParseErrorKind {
     ExpectedAnItemAfterDocComment,
     #[error("Expected a comma or closing parenthesis in function arguments.")]
     ExpectedCommaOrCloseParenInFnArgs,
-    #[error("Unrecognized op code.")]
-    UnrecognizedOpCode,
+    #[error("Unknown assembly instruction.")]
+    UnrecognizedOpCode {
+        known_op_codes: &'static [&'static str],
+    },
     #[error("Unexpected token in statement.")]
     UnexpectedTokenInStatement,
     #[error("This expression cannot be assigned to.")]
diff --git a/sway-error/src/type_error.rs b/sway-error/src/type_error.rs
index a4d7d3fd389..a271db5ce56 100644
--- a/sway-error/src/type_error.rs
+++ b/sway-error/src/type_error.rs
@@ -15,7 +15,6 @@ pub enum TypeError {
         received: String,
         help_text: String,
         span: Span,
-        internal: String,
     },
     #[error("This type is not known. Try annotating it with a type annotation.")]
     UnknownType { span: Span },
@@ -30,6 +29,8 @@ pub enum TypeError {
         received: String,
         span: Span,
     },
+    #[error("Literal would overflow because its value does not fit into \"{expected}\"")]
+    LiteralOverflow { expected: String, span: Span },
 }
 
 impl Spanned for TypeError {
@@ -39,6 +40,7 @@ impl Spanned for TypeError {
             MismatchedType { span, .. } => span.clone(),
             UnknownType { span } => span.clone(),
             MatchArmScrutineeWrongType { span, .. } => span.clone(),
+            LiteralOverflow { span, .. } => span.clone(),
         }
     }
 }
diff --git a/sway-error/src/warning.rs b/sway-error/src/warning.rs
index cef06a740cf..78a4ac8953b 100644
--- a/sway-error/src/warning.rs
+++ b/sway-error/src/warning.rs
@@ -4,7 +4,7 @@ use core::fmt;
 
 use either::Either;
 
-use sway_types::{Ident, SourceId, Span, Spanned};
+use sway_types::{Ident, IdentUnique, SourceId, Span, Spanned};
 
 // TODO: since moving to using Idents instead of strings,
 // the warning_content will usually contain a duplicate of the span.
@@ -67,8 +67,14 @@ pub enum Warning {
     ShadowsOtherSymbol {
         name: Ident,
     },
-    UninitializedAsmRegShadowsVariable {
-        name: Ident,
+    AsmBlockIsEmpty,
+    UninitializedAsmRegShadowsItem {
+        /// Text "Constant" or "Configurable" or "Variable".
+        /// Denotes the type of the `item` that shadows the uninitialized ASM register.
+        constant_or_configurable_or_variable: &'static str,
+        /// The name of the item that shadows the register, that points to the name in
+        /// the item declaration.
+        item: IdentUnique,
     },
     OverridingTraitImplementation,
     DeadDeclaration,
@@ -101,7 +107,6 @@ pub enum Warning {
     UnrecognizedAttribute {
         attrib_name: Ident,
     },
-    NamespaceAttributeDeprecated,
     AttributeExpectedNumberOfArguments {
         attrib_name: Ident,
         received_args: usize,
@@ -191,9 +196,8 @@ impl fmt::Display for Warning {
             NonScreamingSnakeCaseConstName { name } => {
                 write!(
                     f,
-                    "Constant name \"{}\" is not idiomatic. Constant names should be SCREAMING_SNAKE_CASE, like \
+                    "Constant name \"{name}\" is not idiomatic. Constant names should be SCREAMING_SNAKE_CASE, like \
                     \"{}\".",
-                    name,
                     to_screaming_snake_case(name.as_str()),
                 )
             },
@@ -211,9 +215,14 @@ impl fmt::Display for Warning {
                 f,
                 "This shadows another symbol in this scope with the same name \"{name}\"."
             ),
-            UninitializedAsmRegShadowsVariable { name } => write!(
+            AsmBlockIsEmpty => write!(
+                f,
+                "This ASM block is empty."
+            ),
+            UninitializedAsmRegShadowsItem { constant_or_configurable_or_variable, item } => write!(
                 f,
-                "This uninitialized register is shadowing a variable, you probably meant to also initialize it like \"{name}: {name}\"."
+                "This uninitialized register is shadowing a {}. You probably meant to also initialize it, like \"{item}: {item}\".",
+                constant_or_configurable_or_variable.to_ascii_lowercase(),
             ),
             OverridingTraitImplementation => write!(
                 f,
@@ -245,13 +254,6 @@ impl fmt::Display for Warning {
             ),
             MatchExpressionUnreachableArm { .. } => write!(f, "This match arm is unreachable."),
             UnrecognizedAttribute {attrib_name} => write!(f, "Unknown attribute: \"{attrib_name}\"."),
-            NamespaceAttributeDeprecated => write!(f, "Attribute namespace is deprecated.\n\
-            You can use namespaces inside storage:\n\
-            storage {{\n\
-            \tmy_storage_namespace {{\n\
-            \t\tfield: u64 = 1, \n\
-            \t}}\n\
-            }}"),
             AttributeExpectedNumberOfArguments {attrib_name, received_args, expected_min_len, expected_max_len } => write!(
                 f,
                 "Attribute: \"{attrib_name}\" expected {} argument(s) received {received_args}.",
@@ -368,6 +370,48 @@ impl ToDiagnostic for CompileWarning {
                     ]
                 }
             },
+            UninitializedAsmRegShadowsItem { constant_or_configurable_or_variable, item } => Diagnostic {
+                reason: Some(Reason::new(code(1), format!("Uninitialized ASM register is shadowing a {}", constant_or_configurable_or_variable.to_ascii_lowercase()))),
+                issue: Issue::warning(
+                    source_engine,
+                    self.span(),
+                    format!("Uninitialized register \"{item}\" is shadowing a {} of the same name.", constant_or_configurable_or_variable.to_ascii_lowercase()),
+                ),
+                hints: {
+                    let mut hints = vec![
+                        Hint::info(
+                            source_engine,
+                            item.span(),
+                            format!("{constant_or_configurable_or_variable} \"{item}\" is declared here.")
+                        ),
+                    ];
+
+                    hints.append(&mut Hint::multi_help(
+                        source_engine,
+                        &self.span(),
+                        vec![
+                            format!("Are you trying to initialize the register to the value of the {}?", constant_or_configurable_or_variable.to_ascii_lowercase()),
+                            format!("In that case, you must do it explicitly: `{item}: {item}`."),
+                            format!("Otherwise, to avoid the confusion with the shadowed {}, consider renaming the register \"{item}\".", constant_or_configurable_or_variable.to_ascii_lowercase()),
+                        ]
+                    ));
+
+                    hints
+                },
+                help: vec![],
+            },
+            AsmBlockIsEmpty => Diagnostic {
+                reason: Some(Reason::new(code(1), "ASM block is empty".to_string())),
+                issue: Issue::warning(
+                    source_engine,
+                    self.span(),
+                    "This ASM block is empty.".to_string(),
+                ),
+                hints: vec![],
+                help: vec![
+                    "Consider adding assembly instructions or a return register to the ASM block, or removing the block altogether.".to_string(),
+                ],
+            },
            _ => Diagnostic {
                     // TODO: Temporary we use self here to achieve backward compatibility.
                     //       In general, self must not be used and will not be used once we
diff --git a/sway-ir/Cargo.toml b/sway-ir/Cargo.toml
index 6206f94ffa4..a3c4b58f722 100644
--- a/sway-ir/Cargo.toml
+++ b/sway-ir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-ir"
-version = "0.60.0"
+version.workspace = true
 description = "Sway intermediate representation."
 authors.workspace = true
 edition.workspace = true
@@ -9,19 +9,19 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1.0"
-downcast-rs = "1.2.0"
-filecheck = "0.5"
-indexmap = { version = "2.0.0", features = ["rayon"] }
-itertools = "0.10.3"
-once_cell = "1.18.0"
-peg = "0.7"
-prettydiff = "0.6.4"
-rustc-hash = "1.1.0"
-slotmap = "1.0.7"
-sway-ir-macros = { version = "0.60.0", path = "sway-ir-macros" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
+anyhow.workspace = true
+downcast-rs.workspace = true
+filecheck.workspace = true
+indexmap = { workspace = true, features = ["rayon"] }
+itertools.workspace = true
+once_cell.workspace = true
+peg.workspace = true
+prettydiff.workspace = true
+rustc-hash.workspace = true
+slotmap.workspace = true
+sway-ir-macros.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
 
 [lints.clippy]
 iter_over_hash_type = "deny"
diff --git a/sway-ir/src/analysis/dominator.rs b/sway-ir/src/analysis/dominator.rs
index 72de08fb690..9919cd2f556 100644
--- a/sway-ir/src/analysis/dominator.rs
+++ b/sway-ir/src/analysis/dominator.rs
@@ -28,7 +28,8 @@ impl DomTreeNode {
 }
 
 // The dominator tree is represented by mapping each Block to its DomTreeNode.
-pub type DomTree = FxIndexMap<Block, DomTreeNode>;
+#[derive(Default)]
+pub struct DomTree(FxIndexMap<Block, DomTreeNode>);
 impl AnalysisResultT for DomTree {}
 
 // Dominance frontier sets.
@@ -120,11 +121,11 @@ fn compute_dom_tree(
     let entry = function.get_entry_block(context);
 
     // This is to make the algorithm happy. It'll be changed to None later.
-    dom_tree.insert(entry, DomTreeNode::new(Some(entry)));
+    dom_tree.0.insert(entry, DomTreeNode::new(Some(entry)));
     // initialize the dominators tree. This allows us to do dom_tree[b] fearlessly.
     // Note that we just previously initialized "entry", so we skip that here.
     for b in po.po_to_block.iter().take(po.po_to_block.len() - 1) {
-        dom_tree.insert(*b, DomTreeNode::new(None));
+        dom_tree.0.insert(*b, DomTreeNode::new(None));
     }
     let mut changed = true;
 
@@ -149,12 +150,12 @@ fn compute_dom_tree(
                 .pred_iter(context)
                 .filter(|p| **p != picked_pred && po.block_to_po.contains_key(p))
             {
-                if dom_tree[p].parent.is_some() {
+                if dom_tree.0[p].parent.is_some() {
                     // if doms[p] already calculated
                     new_idom = intersect(po, &dom_tree, *p, new_idom);
                 }
             }
-            let b_node = dom_tree.get_mut(b).unwrap();
+            let b_node = dom_tree.0.get_mut(b).unwrap();
             match b_node.parent {
                 Some(idom) if idom == new_idom => {}
                 _ => {
@@ -175,29 +176,54 @@ fn compute_dom_tree(
     ) -> Block {
         while finger1 != finger2 {
             while po.block_to_po[&finger1] < po.block_to_po[&finger2] {
-                finger1 = dom_tree[&finger1].parent.unwrap();
+                finger1 = dom_tree.0[&finger1].parent.unwrap();
             }
             while po.block_to_po[&finger2] < po.block_to_po[&finger1] {
-                finger2 = dom_tree[&finger2].parent.unwrap();
+                finger2 = dom_tree.0[&finger2].parent.unwrap();
             }
         }
         finger1
     }
 
     // Fix the root.
-    dom_tree.get_mut(&entry).unwrap().parent = None;
+    dom_tree.0.get_mut(&entry).unwrap().parent = None;
     // Build the children.
     let child_parent: Vec<_> = dom_tree
+        .0
         .iter()
         .filter_map(|(n, n_node)| n_node.parent.map(|n_parent| (*n, n_parent)))
         .collect();
     for (child, parent) in child_parent {
-        dom_tree.get_mut(&parent).unwrap().children.push(child);
+        dom_tree.0.get_mut(&parent).unwrap().children.push(child);
     }
 
     Ok(Box::new(dom_tree))
 }
 
+impl DomTree {
+    /// Does `dominator` dominate `dominatee`?
+    pub fn dominates(&self, dominator: Block, dominatee: Block) -> bool {
+        let mut node_opt = Some(dominatee);
+        while let Some(node) = node_opt {
+            if node == dominator {
+                return true;
+            }
+            node_opt = self.0[&node].parent;
+        }
+        false
+    }
+
+    /// Get an iterator over the children nodes
+    pub fn children(&self, node: Block) -> impl Iterator<Item = Block> + '_ {
+        self.0[&node].children.iter().cloned()
+    }
+
+    /// Get i'th child of a given node
+    pub fn child(&self, node: Block, i: usize) -> Option<Block> {
+        self.0[&node].children.get(i).cloned()
+    }
+}
+
 pub const DOM_FRONTS_NAME: &str = "dominance-frontiers";
 
 pub fn create_dom_fronts_pass() -> Pass {
@@ -217,23 +243,23 @@ fn compute_dom_fronts(
 ) -> Result<AnalysisResult, IrError> {
     let dom_tree: &DomTree = analyses.get_analysis_result(function);
     let mut res = DomFronts::default();
-    for (b, _) in dom_tree.iter() {
+    for (b, _) in dom_tree.0.iter() {
         res.insert(*b, IndexSet::default());
     }
 
     // for all nodes, b
-    for (b, _) in dom_tree.iter() {
+    for (b, _) in dom_tree.0.iter() {
         // if the number of predecessors of b >= 2
         if b.num_predecessors(context) > 1 {
             // unwrap() is safe as b is not "entry", and hence must have idom.
-            let b_idom = dom_tree[b].parent.unwrap();
+            let b_idom = dom_tree.0[b].parent.unwrap();
             // for all (reachable) predecessors, p, of b
-            for p in b.pred_iter(context).filter(|&p| dom_tree.contains_key(p)) {
+            for p in b.pred_iter(context).filter(|&p| dom_tree.0.contains_key(p)) {
                 let mut runner = *p;
                 while runner != b_idom {
                     // add b to runner’s dominance frontier set
                     res.get_mut(&runner).unwrap().insert(*b);
-                    runner = dom_tree[&runner].parent.unwrap();
+                    runner = dom_tree.0[&runner].parent.unwrap();
                 }
             }
         }
@@ -244,7 +270,7 @@ fn compute_dom_fronts(
 /// Print dominator tree in the graphviz dot format.
 pub fn print_dot(context: &Context, func_name: &str, dom_tree: &DomTree) -> String {
     let mut res = format!("digraph {func_name} {{\n");
-    for (b, idom) in dom_tree.iter() {
+    for (b, idom) in dom_tree.0.iter() {
         if let Some(idom) = idom.parent {
             let _ = writeln!(
                 res,
diff --git a/sway-ir/src/analysis/memory_utils.rs b/sway-ir/src/analysis/memory_utils.rs
index 10f841f5ae6..ab6acdc6f4d 100644
--- a/sway-ir/src/analysis/memory_utils.rs
+++ b/sway-ir/src/analysis/memory_utils.rs
@@ -50,6 +50,8 @@ impl Symbol {
 /// A `val` can, via GEP instructions, refer indirectly to none, or one
 /// or more symbols.
 ///
+/// If the `val` is not a pointer, an empty set is returned.
+///
 /// Note that this function does not return [Symbol]s potentially reachable
 /// via referencing (`&`), dereferencing (`*`), and raw pointers (`__addr_of`)
 /// and is thus suitable for all IR analysis and manipulation that deals
@@ -84,16 +86,24 @@ pub enum ReferredSymbols {
 }
 
 impl ReferredSymbols {
-    // TODO: Check all the usages of this method and replace it with the
-    //       checked access to either complete or incomplete symbols.
-    //       This is a temporary convenience method until
-    //       we decide case by case how to deal with incomplete set of symbols.
-    //       See: https://github.com/FuelLabs/sway/issues/5924
-    pub fn any(self) -> FxIndexSet<Symbol> {
-        match self {
-            ReferredSymbols::Complete(symbols) | ReferredSymbols::Incomplete(symbols) => symbols,
+    pub fn new(is_complete: bool, symbols: FxIndexSet<Symbol>) -> Self {
+        if is_complete {
+            Self::Complete(symbols)
+        } else {
+            Self::Incomplete(symbols)
         }
     }
+
+    /// Returns the referred [Symbol]s and the information if they are
+    /// complete (true) or incomplete (false).
+    pub fn consume(self) -> (bool, FxIndexSet<Symbol>) {
+        let is_complete = matches!(self, ReferredSymbols::Complete(_));
+        let syms = match self {
+            ReferredSymbols::Complete(syms) | ReferredSymbols::Incomplete(syms) => syms,
+        };
+
+        (is_complete, syms)
+    }
 }
 
 /// Get [Symbol]s, both [Symbol::Local]s and [Symbol::Arg]s, reachable
@@ -119,6 +129,9 @@ impl ReferredSymbols {
 /// Therefore, the function returns the [ReferredSymbols] enum to denote
 /// if the returned set of symbols is guaranteed to be complete, or if it is
 /// incomplete.
+///
+/// If the `val` is not a pointer, an empty set is returned and marked as
+/// [ReferredSymbols::Complete].
 pub fn get_referred_symbols(context: &Context, val: Value) -> ReferredSymbols {
     get_symbols(context, val, false)
 }
@@ -129,12 +142,17 @@ pub fn get_referred_symbols(context: &Context, val: Value) -> ReferredSymbols {
 /// If `gep_only` is `true` only the [Symbol]s reachable via GEP instructions
 /// are returned. Otherwise, the result also contains [Symbol]s reachable
 /// via referencing (`&`) and dereferencing (`*`).
+///
+/// If the `val` is not a pointer, an empty set is returned and marked as
+/// [ReferredSymbols::Complete].
 fn get_symbols(context: &Context, val: Value, gep_only: bool) -> ReferredSymbols {
+    // The input to this recursive function is always a pointer.
+    // The function tracks backwards where the pointer is coming from.
     fn get_symbols_rec(
         context: &Context,
         symbols: &mut FxIndexSet<Symbol>,
         visited: &mut FxHashSet<Value>,
-        val: Value,
+        ptr: Value,
         gep_only: bool,
         is_complete: &mut bool,
     ) {
@@ -158,11 +176,87 @@ fn get_symbols(context: &Context, val: Value, gep_only: bool) -> ReferredSymbols
             }
         }
 
-        if visited.contains(&val) {
+        fn get_symbols_from_u64_address_argument(
+            context: &Context,
+            symbols: &mut FxIndexSet<Symbol>,
+            visited: &mut FxHashSet<Value>,
+            u64_address_arg: BlockArgument,
+            is_complete: &mut bool,
+        ) {
+            if u64_address_arg.block.get_label(context) == "entry" {
+                // The u64 address is coming from a function argument.
+                // Same as in the case of a pointer coming from a function argument,
+                // we collect it.
+                symbols.insert(Symbol::Arg(u64_address_arg));
+            } else {
+                u64_address_arg
+                    .block
+                    .pred_iter(context)
+                    .map(|pred| u64_address_arg.get_val_coming_from(context, pred).unwrap())
+                    .for_each(|v| {
+                        get_symbols_from_u64_address_rec(context, symbols, visited, v, is_complete)
+                    })
+            }
+        }
+
+        // The input to this recursive function is always a `u64` holding an address.
+        // The below chain of instructions are specific to patterns where pointers
+        // are obtained from `u64` addresses and vice versa. This includes:
+        //  - referencing and dereferencing
+        //  - raw pointers (`__addr_of`)
+        //  - GTF intrinsic
+        fn get_symbols_from_u64_address_rec(
+            context: &Context,
+            symbols: &mut FxIndexSet<Symbol>,
+            visited: &mut FxHashSet<Value>,
+            u64_address: Value,
+            is_complete: &mut bool,
+        ) {
+            match context.values[u64_address.0].value {
+                // Follow the sources of the address, and for every source address,
+                // recursively come back to this function.
+                ValueDatum::Argument(arg) => get_symbols_from_u64_address_argument(
+                    context,
+                    symbols,
+                    visited,
+                    arg,
+                    is_complete,
+                ),
+                // 1. Patterns related to references and raw pointers.
+                ValueDatum::Instruction(Instruction {
+                    // The address is coming from a `raw_pointer` or `&T` variable.
+                    op: InstOp::Load(_loaded_from),
+                    ..
+                }) => {
+                    // TODO: https://github.com/FuelLabs/sway/issues/6065
+                    //       We want to track sources of loaded addresses.
+                    //       Currently we don't and simply mark the result as incomplete.
+                    *is_complete = false;
+                }
+                ValueDatum::Instruction(Instruction {
+                    op: InstOp::PtrToInt(ptr_value, _),
+                    ..
+                }) => get_symbols_rec(context, symbols, visited, ptr_value, false, is_complete),
+                // 2. The address is coming from a GTF instruction.
+                ValueDatum::Instruction(Instruction {
+                    // There cannot be a symbol behind it, and so the returned set is complete.
+                    op: InstOp::FuelVm(FuelVmInstruction::Gtf { .. }),
+                    ..
+                }) => (),
+                // In other cases, e.g., getting the integer address from an unsafe pointer
+                // arithmetic, or as a function result, etc. we bail out and mark the
+                // collection as not being guaranteed to be a complete set of all referred symbols.
+                _ => {
+                    *is_complete = false;
+                }
+            }
+        }
+
+        if visited.contains(&ptr) {
             return;
         }
-        visited.insert(val);
-        match context.values[val.0].value {
+        visited.insert(ptr);
+        match context.values[ptr.0].value {
             ValueDatum::Instruction(Instruction {
                 op: InstOp::GetLocal(local),
                 ..
@@ -173,59 +267,58 @@ fn get_symbols(context: &Context, val: Value, gep_only: bool) -> ReferredSymbols
                 op: InstOp::GetElemPtr { base, .. },
                 ..
             }) => get_symbols_rec(context, symbols, visited, base, gep_only, is_complete),
-            // The below chain of instructions are specific to
-            // referencing, dereferencing, and `__addr_of` and do not occur
-            // in other kinds of IR generation.  E.g., `IntToPtr` could be emitted when
-            // GTF intrinsic is compiled, but do not produce
-            // the below patterns which are specific to references and raw pointers.
             ValueDatum::Instruction(Instruction {
-                op: InstOp::IntToPtr(int_value, _),
+                op: InstOp::IntToPtr(u64_address, _),
                 ..
-            }) if !gep_only => {
-                // Ignore this path if only GEP chain is requested.
-                match context.values[int_value.0].value {
-                    ValueDatum::Instruction(Instruction {
-                        op: InstOp::Load(loaded_from),
-                        ..
-                    }) => get_symbols_rec(
-                        context,
-                        symbols,
-                        visited,
-                        loaded_from,
-                        gep_only,
-                        is_complete,
-                    ),
-                    ValueDatum::Instruction(Instruction {
-                        op: InstOp::PtrToInt(ptr_value, _),
-                        ..
-                    }) => {
-                        get_symbols_rec(context, symbols, visited, ptr_value, gep_only, is_complete)
-                    }
-                    ValueDatum::Argument(arg) => {
-                        get_argument_symbols(context, symbols, visited, arg, gep_only, is_complete)
-                    }
-                    // In other cases, e.g., getting the integer address from an unsafe pointer
-                    // arithmetic, or as a function result, etc. we bail out and mark the
-                    // collection as not being guaranteed to be a complete set of all referred symbols.
-                    _ => {
-                        *is_complete = false;
-                    }
-                }
-            }
-            // In case of converting pointer to int for references and raw pointers,
-            // we consider the pointed symbols to be reachable from the `ptr_value`.
+            }) if !gep_only => get_symbols_from_u64_address_rec(
+                context,
+                symbols,
+                visited,
+                u64_address,
+                is_complete,
+            ),
+            // We've reached a configurable at the top of the chain.
+            // There cannot be a symbol behind it, and so the returned set is complete.
             ValueDatum::Instruction(Instruction {
-                op: InstOp::PtrToInt(ptr_value, _),
+                op: InstOp::GetConfig(_, _),
                 ..
-            }) if !gep_only => {
-                get_symbols_rec(context, symbols, visited, ptr_value, gep_only, is_complete)
-            }
+            }) if !gep_only => (),
+            // Note that in this case, the pointer itself is coming from a `Load`,
+            // and not an address. So, we just continue following the pointer.
+            ValueDatum::Instruction(Instruction {
+                op: InstOp::Load(loaded_from),
+                ..
+            }) if !gep_only => get_symbols_rec(
+                context,
+                symbols,
+                visited,
+                loaded_from,
+                gep_only,
+                is_complete,
+            ),
+            ValueDatum::Instruction(Instruction {
+                op: InstOp::CastPtr(ptr_to_cast, _),
+                ..
+            }) if !gep_only => get_symbols_rec(
+                context,
+                symbols,
+                visited,
+                ptr_to_cast,
+                gep_only,
+                is_complete,
+            ),
             ValueDatum::Argument(arg) => {
                 get_argument_symbols(context, symbols, visited, arg, gep_only, is_complete)
             }
+            // We've reached a constant at the top of the chain.
+            // There cannot be a symbol behind it, and so the returned set is complete.
+            ValueDatum::Constant(_) if !gep_only => (),
             _ if !gep_only => {
-                // Same as above, we cannot track the value up the chain and cannot guarantee
-                // that the value is not coming from some of the symbols.
+                // In other cases, e.g., getting the pointer from an ASM block,
+                // or as a function result, etc., we cannot track the value up the chain
+                // and cannot guarantee that the value is not coming from some of the symbols.
+                // So, we bail out and mark the collection as not being guaranteed to be
+                // a complete set of all referred symbols.
                 *is_complete = false;
             }
             // In the case of GEP only access, the returned set is always complete.
@@ -233,6 +326,10 @@ fn get_symbols(context: &Context, val: Value, gep_only: bool) -> ReferredSymbols
         }
     }
 
+    if !val.get_type(context).map_or(false, |t| t.is_ptr(context)) {
+        return ReferredSymbols::new(true, IndexSet::default());
+    }
+
     let mut visited = FxHashSet::default();
     let mut symbols = IndexSet::default();
     let mut is_complete = true;
@@ -246,11 +343,7 @@ fn get_symbols(context: &Context, val: Value, gep_only: bool) -> ReferredSymbols
         &mut is_complete,
     );
 
-    if is_complete {
-        ReferredSymbols::Complete(symbols)
-    } else {
-        ReferredSymbols::Incomplete(symbols)
-    }
+    ReferredSymbols::new(is_complete, symbols)
 }
 
 pub fn get_gep_symbol(context: &Context, val: Value) -> Option<Symbol> {
@@ -260,14 +353,28 @@ pub fn get_gep_symbol(context: &Context, val: Value) -> Option<Symbol> {
         .flatten()
 }
 
+/// Return [Symbol] referred by `val` if there is _exactly one_ symbol referred,
+/// or `None` if there are no [Symbol]s referred or if there is more then one
+/// referred.
 pub fn get_referred_symbol(context: &Context, val: Value) -> Option<Symbol> {
-    let syms = get_referred_symbols(context, val).any();
-    (syms.len() == 1)
-        .then(|| syms.iter().next().cloned())
-        .flatten()
+    let syms = get_referred_symbols(context, val);
+    match syms {
+        ReferredSymbols::Complete(syms) => (syms.len() == 1)
+            .then(|| syms.iter().next().cloned())
+            .flatten(),
+        // It might be that we have more than one referred symbol here.
+        ReferredSymbols::Incomplete(_) => None,
+    }
+}
+
+pub enum EscapedSymbols {
+    /// Guarantees that all escaping [Symbol]s are collected.
+    Complete(FxHashSet<Symbol>),
+    /// Denotes that there _might_ be additional escaping [Symbol]s
+    /// out of the collected ones.
+    Incomplete(FxHashSet<Symbol>),
 }
 
-pub type EscapedSymbols = FxHashSet<Symbol>;
 impl AnalysisResultT for EscapedSymbols {}
 
 pub fn compute_escaped_symbols_pass(
@@ -279,33 +386,39 @@ pub fn compute_escaped_symbols_pass(
 }
 
 pub fn compute_escaped_symbols(context: &Context, function: &Function) -> EscapedSymbols {
-    let mut result = FxHashSet::default();
+    let add_from_val = |result: &mut FxHashSet<Symbol>, val: &Value, is_complete: &mut bool| {
+        let (complete, syms) = get_referred_symbols(context, *val).consume();
 
-    let add_from_val = |result: &mut FxHashSet<Symbol>, val: &Value| {
-        get_referred_symbols(context, *val)
-            .any()
-            .iter()
-            .for_each(|s| {
-                result.insert(*s);
-            });
+        *is_complete &= complete;
+
+        syms.iter().for_each(|s| {
+            result.insert(*s);
+        });
     };
 
+    let mut result = FxHashSet::default();
+    let mut is_complete = true;
+
     for (_block, inst) in function.instruction_iter(context) {
         match &inst.get_instruction(context).unwrap().op {
             InstOp::AsmBlock(_, args) => {
                 for arg_init in args.iter().filter_map(|arg| arg.initializer) {
-                    add_from_val(&mut result, &arg_init)
+                    add_from_val(&mut result, &arg_init, &mut is_complete)
                 }
             }
             InstOp::UnaryOp { .. } => (),
             InstOp::BinaryOp { .. } => (),
             InstOp::BitCast(_, _) => (),
             InstOp::Branch(_) => (),
-            InstOp::Call(_, args) => args.iter().for_each(|v| add_from_val(&mut result, v)),
+            InstOp::Call(_, args) => args
+                .iter()
+                .for_each(|v| add_from_val(&mut result, v, &mut is_complete)),
             InstOp::CastPtr(_, _) => (),
             InstOp::Cmp(_, _, _) => (),
             InstOp::ConditionalBranch { .. } => (),
-            InstOp::ContractCall { params, .. } => add_from_val(&mut result, params),
+            InstOp::ContractCall { params, .. } => {
+                add_from_val(&mut result, params, &mut is_complete)
+            }
             InstOp::FuelVm(_) => (),
             InstOp::GetLocal(_) => (),
             InstOp::GetConfig(_, _) => (),
@@ -315,18 +428,22 @@ pub fn compute_escaped_symbols(context: &Context, function: &Function) -> Escape
             InstOp::MemCopyBytes { .. } => (),
             InstOp::MemCopyVal { .. } => (),
             InstOp::Nop => (),
-            InstOp::PtrToInt(v, _) => add_from_val(&mut result, v),
+            InstOp::PtrToInt(v, _) => add_from_val(&mut result, v, &mut is_complete),
             InstOp::Ret(_, _) => (),
             InstOp::Store { .. } => (),
         }
     }
 
-    result
+    if is_complete {
+        EscapedSymbols::Complete(result)
+    } else {
+        EscapedSymbols::Incomplete(result)
+    }
 }
 
-/// Pointers that may possibly be loaded from.
-pub fn get_loaded_ptr_values(context: &Context, val: Value) -> Vec<Value> {
-    match &val.get_instruction(context).unwrap().op {
+/// Pointers that may possibly be loaded from the instruction `inst`.
+pub fn get_loaded_ptr_values(context: &Context, inst: Value) -> Vec<Value> {
+    match &inst.get_instruction(context).unwrap().op {
         InstOp::UnaryOp { .. }
         | InstOp::BinaryOp { .. }
         | InstOp::BitCast(_, _)
@@ -392,20 +509,26 @@ pub fn get_loaded_ptr_values(context: &Context, val: Value) -> Vec<Value> {
     }
 }
 
-/// Symbols that may possibly be loaded from.
-pub fn get_loaded_symbols(context: &Context, val: Value) -> FxIndexSet<Symbol> {
+/// [Symbol]s that may possibly, directly or indirectly, be loaded from the instruction `inst`.
+pub fn get_loaded_symbols(context: &Context, inst: Value) -> ReferredSymbols {
     let mut res = IndexSet::default();
-    for val in get_loaded_ptr_values(context, val) {
-        for sym in get_referred_symbols(context, val).any() {
+    let mut is_complete = true;
+    for val in get_loaded_ptr_values(context, inst) {
+        let (complete, syms) = get_referred_symbols(context, val).consume();
+
+        is_complete &= complete;
+
+        for sym in syms {
             res.insert(sym);
         }
     }
-    res
+
+    ReferredSymbols::new(is_complete, res)
 }
 
-/// Pointers that may possibly be stored to.
-pub fn get_stored_ptr_values(context: &Context, val: Value) -> Vec<Value> {
-    match &val.get_instruction(context).unwrap().op {
+/// Pointers that may possibly be stored to the instruction `inst`.
+pub fn get_stored_ptr_values(context: &Context, inst: Value) -> Vec<Value> {
+    match &inst.get_instruction(context).unwrap().op {
         InstOp::UnaryOp { .. }
         | InstOp::BinaryOp { .. }
         | InstOp::BitCast(_, _)
@@ -449,15 +572,21 @@ pub fn get_stored_ptr_values(context: &Context, val: Value) -> Vec<Value> {
     }
 }
 
-/// Symbols that may possibly be stored to.
-pub fn get_stored_symbols(context: &Context, val: Value) -> FxIndexSet<Symbol> {
+/// [Symbol]s that may possibly, directly or indirectly, be stored to the instruction `inst`.
+pub fn get_stored_symbols(context: &Context, inst: Value) -> ReferredSymbols {
     let mut res = IndexSet::default();
-    for val in get_stored_ptr_values(context, val) {
-        for sym in get_referred_symbols(context, val).any() {
+    let mut is_complete = true;
+    for val in get_stored_ptr_values(context, inst) {
+        let (complete, syms) = get_referred_symbols(context, val).consume();
+
+        is_complete &= complete;
+
+        for sym in syms {
             res.insert(sym);
         }
     }
-    res
+
+    ReferredSymbols::new(is_complete, res)
 }
 
 /// Combine a series of GEPs into one.
diff --git a/sway-ir/src/asm.rs b/sway-ir/src/asm.rs
index 8a74df16ecf..b6f4cd657c9 100644
--- a/sway-ir/src/asm.rs
+++ b/sway-ir/src/asm.rs
@@ -43,6 +43,82 @@ pub struct AsmInstruction {
     pub metadata: Option<MetadataIndex>,
 }
 
+impl AsmInstruction {
+    pub fn log_no_span(
+        ra: impl Into<String>,
+        rb: impl Into<String>,
+        rc: impl Into<String>,
+        rd: impl Into<String>,
+    ) -> Self {
+        AsmInstruction {
+            op_name: Ident::new(sway_types::Span::from_string("log".into())),
+            args: vec![
+                Ident::new_no_span(ra.into()),
+                Ident::new_no_span(rb.into()),
+                Ident::new_no_span(rc.into()),
+                Ident::new_no_span(rd.into()),
+            ],
+            immediate: None,
+            metadata: None,
+        }
+    }
+
+    pub fn lw_no_span(
+        dst: impl Into<String>,
+        src: impl Into<String>,
+        offset: impl Into<String>,
+    ) -> Self {
+        AsmInstruction {
+            op_name: Ident::new(sway_types::Span::from_string("lw".into())),
+            args: vec![
+                Ident::new_no_span(dst.into()),
+                Ident::new_no_span(src.into()),
+            ],
+            immediate: Some(Ident::new_no_span(offset.into())),
+            metadata: None,
+        }
+    }
+
+    pub fn mul_no_span(dst: impl Into<String>, a: impl Into<String>, b: impl Into<String>) -> Self {
+        AsmInstruction {
+            op_name: Ident::new(sway_types::Span::from_string("mul".into())),
+            args: vec![
+                Ident::new_no_span(dst.into()),
+                Ident::new_no_span(a.into()),
+                Ident::new_no_span(b.into()),
+            ],
+            immediate: None,
+            metadata: None,
+        }
+    }
+
+    pub fn add_no_span(dst: impl Into<String>, a: impl Into<String>, b: impl Into<String>) -> Self {
+        AsmInstruction {
+            op_name: Ident::new(sway_types::Span::from_string("add".into())),
+            args: vec![
+                Ident::new_no_span(dst.into()),
+                Ident::new_no_span(a.into()),
+                Ident::new_no_span(b.into()),
+            ],
+            immediate: None,
+            metadata: None,
+        }
+    }
+
+    pub fn sub_no_span(dst: impl Into<String>, a: impl Into<String>, b: impl Into<String>) -> Self {
+        AsmInstruction {
+            op_name: Ident::new(sway_types::Span::from_string("sub".into())),
+            args: vec![
+                Ident::new_no_span(dst.into()),
+                Ident::new_no_span(a.into()),
+                Ident::new_no_span(b.into()),
+            ],
+            immediate: None,
+            metadata: None,
+        }
+    }
+}
+
 impl AsmBlock {
     /// Create a new [`AsmBlock`] in the passed context and return its handle.
     pub fn new(
diff --git a/sway-ir/src/block.rs b/sway-ir/src/block.rs
index b16e7212ad7..fb56b644059 100644
--- a/sway-ir/src/block.rs
+++ b/sway-ir/src/block.rs
@@ -120,7 +120,7 @@ impl Block {
         context.blocks[self.0].label = unique_label;
     }
 
-    /// Get the number of instructions in this block
+    /// Get the number of instructions in this block.
     pub fn num_instructions(&self, context: &Context) -> usize {
         context.blocks[self.0].instructions.len()
     }
@@ -369,14 +369,21 @@ impl Block {
         }
     }
 
-    /// Return whether this block is already terminated specifically by a Ret instruction.
-    pub fn is_terminated_by_ret_or_revert(&self, context: &Context) -> bool {
+    /// Return whether this block is already terminated by non-branching instructions,
+    /// means with instructions that cause either revert, or local or context returns.
+    /// Those instructions are: [InstOp::Ret], [FuelVmInstruction::Retd],
+    /// [FuelVmInstruction::JmpMem], and [FuelVmInstruction::Revert]).
+    pub fn is_terminated_by_return_or_revert(&self, context: &Context) -> bool {
         self.get_terminator(context).map_or(false, |i| {
             matches!(
                 i,
                 Instruction {
                     op: InstOp::Ret(..)
-                        | InstOp::FuelVm(FuelVmInstruction::Revert(..) | FuelVmInstruction::JmpMem),
+                        | InstOp::FuelVm(
+                            FuelVmInstruction::Revert(..)
+                                | FuelVmInstruction::JmpMem
+                                | FuelVmInstruction::Retd { .. }
+                        ),
                     ..
                 }
             )
diff --git a/sway-ir/src/constant.rs b/sway-ir/src/constant.rs
index 9aaae3c4218..b3715b16803 100644
--- a/sway-ir/src/constant.rs
+++ b/sway-ir/src/constant.rs
@@ -23,6 +23,7 @@ pub enum ConstantValue {
     B256(B256),
     String(Vec<u8>),
     Array(Vec<Constant>),
+    Slice(Vec<Constant>),
     Struct(Vec<Constant>),
     Reference(Box<Constant>),
     RawUntypedSlice(Vec<u8>),
@@ -269,4 +270,11 @@ impl Constant {
                 _ => false,
             }
     }
+
+    pub fn as_uint(&self) -> Option<u64> {
+        match &self.value {
+            ConstantValue::Uint(v) => Some(*v),
+            _ => None,
+        }
+    }
 }
diff --git a/sway-ir/src/error.rs b/sway-ir/src/error.rs
index 44fa75b1892..80b0894fe16 100644
--- a/sway-ir/src/error.rs
+++ b/sway-ir/src/error.rs
@@ -21,6 +21,7 @@ pub enum IrError {
     VerifyBinaryOpIncorrectArgType,
     VerifyBitcastBetweenInvalidTypes(String, String),
     VerifyBitcastUnknownSourceType,
+    VerifyEntryBlockHasPredecessors(String, Vec<String>),
     VerifyBlockArgMalformed,
     VerifyBranchParamsMismatch,
     VerifyBranchToMissingBlock(String),
@@ -32,8 +33,8 @@ pub enum IrError {
     VerifyConditionExprNotABool,
     VerifyContractCallBadTypes(String),
     VerifyGepElementTypeNonPointer,
-    VerifyGepFromNonPointer(String),
-    VerifyGepInconsistentTypes,
+    VerifyGepFromNonPointer(String, Option<Value>),
+    VerifyGepInconsistentTypes(String, Option<crate::Value>),
     VerifyGepOnNonAggregate,
     VerifyGetNonExistentPointer,
     VerifyInsertElementOfIncorrectType,
@@ -63,15 +64,28 @@ pub enum IrError {
     VerifyStateDestBadType(String),
     VerifyStateKeyBadType,
     VerifyStateKeyNonPointer(String),
-    VerifyStoreMismatchedTypes,
+    VerifyStoreMismatchedTypes(Option<Value>),
     VerifyStoreToNonPointer(String),
     VerifyUntypedValuePassedToFunction,
 }
+impl IrError {
+    pub(crate) fn get_problematic_value(&self) -> Option<&Value> {
+        match self {
+            Self::VerifyGepFromNonPointer(_, v) => v.as_ref(),
+            Self::VerifyGepInconsistentTypes(_, v) => v.as_ref(),
+            Self::VerifyStoreMismatchedTypes(v) => v.as_ref(),
+            _ => None,
+        }
+    }
+}
 
 impl std::error::Error for IrError {}
 
 use std::fmt;
 
+use crate::Value;
+use itertools::Itertools;
+
 impl fmt::Display for IrError {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match self {
@@ -191,10 +205,14 @@ impl fmt::Display for IrError {
             IrError::VerifyGepElementTypeNonPointer => {
                 write!(f, "Verification failed: GEP on a non-pointer.")
             }
-            IrError::VerifyGepInconsistentTypes => {
-                write!(f, "Verification failed: Struct field type mismatch.")
+            IrError::VerifyGepInconsistentTypes(error, _) => {
+                write!(
+                    f,
+                    "Verification failed: Struct field type mismatch: ({}).",
+                    error
+                )
             }
-            IrError::VerifyGepFromNonPointer(ty) => {
+            IrError::VerifyGepFromNonPointer(ty, _) => {
                 write!(
                     f,
                     "Verification failed: Struct access must be to a pointer value, not a {ty}."
@@ -261,6 +279,27 @@ impl fmt::Display for IrError {
                 "Verification failed: \
                 Function {fn_str} return type must match its RET instructions."
             ),
+            IrError::VerifyEntryBlockHasPredecessors(function_name, predecessors) => {
+                let plural_s = if predecessors.len() == 1 { "" } else { "s" };
+                write!(
+                    f,
+                    "Verification failed: Entry block of the function \"{function_name}\" has {}predecessor{}. \
+                     The predecessor{} {} {}.",
+                    if predecessors.len() == 1 {
+                        "a "
+                    } else {
+                        ""
+                    },
+                    plural_s,
+                    plural_s,
+                    if predecessors.len() == 1 {
+                        "is"
+                    } else {
+                        "are"
+                    },
+                    predecessors.iter().map(|block_label| format!("\"{block_label}\"")).collect_vec().join(", ")
+                )
+            }
             IrError::VerifyBlockArgMalformed => {
                 write!(f, "Verification failed: Block argument is malformed")
             }
@@ -313,7 +352,7 @@ impl fmt::Display for IrError {
                     "Verification failed: State access operation must be to a {ty} pointer."
                 )
             }
-            IrError::VerifyStoreMismatchedTypes => {
+            IrError::VerifyStoreMismatchedTypes(_) => {
                 write!(
                     f,
                     "Verification failed: Store value and pointer type mismatch."
diff --git a/sway-ir/src/function.rs b/sway-ir/src/function.rs
index 812a31145b4..cedfee85930 100644
--- a/sway-ir/src/function.rs
+++ b/sway-ir/src/function.rs
@@ -11,6 +11,7 @@ use std::fmt::Write;
 
 use rustc_hash::{FxHashMap, FxHashSet};
 
+use crate::InstOp;
 use crate::{
     block::{Block, BlockIterator, Label},
     constant::Constant,
@@ -38,6 +39,9 @@ pub struct FunctionContent {
     pub module: Module,
     pub is_public: bool,
     pub is_entry: bool,
+    /// True if the function was an entry, before getting wrapped
+    /// by the `__entry` function. E.g, a script `main` function.
+    pub is_original_entry: bool,
     pub is_fallback: bool,
     pub selector: Option<[u8; 4]>,
     pub metadata: Option<MetadataIndex>,
@@ -65,6 +69,7 @@ impl Function {
         selector: Option<[u8; 4]>,
         is_public: bool,
         is_entry: bool,
+        is_original_entry: bool,
         is_fallback: bool,
         metadata: Option<MetadataIndex>,
     ) -> Function {
@@ -78,6 +83,7 @@ impl Function {
             module,
             is_public,
             is_entry,
+            is_original_entry,
             is_fallback,
             selector,
             metadata,
@@ -243,12 +249,44 @@ impl Function {
     }
 
     /// Return the number of instructions in this function.
+    ///
+    /// The [crate::InstOp::AsmBlock] is counted as a single instruction,
+    /// regardless of the number of [crate::asm::AsmInstruction]s in the ASM block.
+    /// E.g., even if the ASM block is empty and contains no instructions, it
+    /// will still be counted as a single instruction.
+    ///
+    /// If you want to count every ASM instruction as an instruction, use
+    /// `num_instructions_incl_asm_instructions` instead.
     pub fn num_instructions(&self, context: &Context) -> usize {
         self.block_iter(context)
             .map(|block| block.num_instructions(context))
             .sum()
     }
 
+    /// Return the number of instructions in this function, including
+    /// the [crate::asm::AsmInstruction]s found in [crate::InstOp::AsmBlock]s.
+    ///
+    /// Every [crate::asm::AsmInstruction] encountered in any of the ASM blocks
+    /// will be counted as an instruction. The [crate::InstOp::AsmBlock] itself
+    /// is not counted but rather replaced with the number of ASM instructions
+    /// found in the block. In other words, empty ASM blocks do not count as
+    /// instructions.
+    ///
+    /// If you want to count [crate::InstOp::AsmBlock]s as single instructions, use
+    /// `num_instructions` instead.
+    pub fn num_instructions_incl_asm_instructions(&self, context: &Context) -> usize {
+        self.instruction_iter(context).fold(0, |num, (_, value)| {
+            match &value
+                .get_instruction(context)
+                .expect("We are iterating through the instructions.")
+                .op
+            {
+                InstOp::AsmBlock(asm, _) => num + asm.body.len(),
+                _ => num + 1,
+            }
+        })
+    }
+
     /// Return the function name.
     pub fn get_name<'a>(&self, context: &'a Context) -> &'a str {
         &context.functions[self.0].name
@@ -285,6 +323,12 @@ impl Function {
         context.functions[self.0].is_entry
     }
 
+    /// Whether or not the function was a program entry point, i.e. `main`, `#[test]` fns or abi
+    /// methods, before it got wrapped within the `__entry` function.
+    pub fn is_original_entry(&self, context: &Context) -> bool {
+        context.functions[self.0].is_original_entry
+    }
+
     /// Whether or not this function is a contract fallback function
     pub fn is_fallback(&self, context: &Context) -> bool {
         context.functions[self.0].is_fallback
diff --git a/sway-ir/src/instruction.rs b/sway-ir/src/instruction.rs
index 4932f4359ff..cd710a609c0 100644
--- a/sway-ir/src/instruction.rs
+++ b/sway-ir/src/instruction.rs
@@ -137,8 +137,9 @@ pub enum FuelVmInstruction {
     ReadRegister(Register),
     /// Revert VM execution.
     Revert(Value),
-    /// - Sends a message to an output via the `smo` FuelVM instruction. The first operand must be
-    /// a `B256` representing the recipient. The second operand is the message data being sent.
+    /// - Sends a message to an output via the `smo` FuelVM instruction.
+    /// - The first operand must be a `B256` representing the recipient.
+    /// - The second operand is the message data being sent.
     /// - `message_size` and `coins` must be of type `U64`.
     Smo {
         recipient: Value,
@@ -204,19 +205,19 @@ pub enum FuelVmInstruction {
 }
 
 /// Comparison operations.
-#[derive(Debug, Clone, Copy, Hash)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub enum Predicate {
     Equal,
     LessThan,
     GreaterThan,
 }
 
-#[derive(Debug, Clone, Copy, Hash)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub enum UnaryOpKind {
     Not,
 }
 
-#[derive(Debug, Clone, Copy, Hash)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub enum BinaryOpKind {
     Add,
     Sub,
@@ -283,7 +284,6 @@ impl InstOp {
             InstOp::FuelVm(FuelVmInstruction::Log { .. }) => Some(Type::get_unit(context)),
             InstOp::FuelVm(FuelVmInstruction::ReadRegister(_)) => Some(Type::get_uint64(context)),
             InstOp::FuelVm(FuelVmInstruction::Smo { .. }) => Some(Type::get_unit(context)),
-            InstOp::FuelVm(FuelVmInstruction::Retd { .. }) => None,
 
             // Load needs to strip the pointer from the source type.
             InstOp::Load(ptr_val) => match &context.values[ptr_val.0].value {
@@ -309,7 +309,11 @@ impl InstOp {
             // These are all terminators which don't return, essentially.  No type.
             InstOp::Branch(_)
             | InstOp::ConditionalBranch { .. }
-            | InstOp::FuelVm(FuelVmInstruction::Revert(..) | FuelVmInstruction::JmpMem)
+            | InstOp::FuelVm(
+                FuelVmInstruction::Revert(..)
+                | FuelVmInstruction::JmpMem
+                | FuelVmInstruction::Retd { .. },
+            )
             | InstOp::Ret(..) => None,
 
             // No-op is also no-type.
@@ -381,10 +385,11 @@ impl InstOp {
                 vals
             }
             InstOp::GetLocal(_local_var) => {
-                // TODO: Not sure.
+                // `GetLocal` returns an SSA `Value` but does not take any as an operand.
                 vec![]
             }
             InstOp::GetConfig(_, _) => {
+                // `GetConfig` returns an SSA `Value` but does not take any as an operand.
                 vec![]
             }
             InstOp::IntToPtr(v, _) => vec![*v],
@@ -644,8 +649,8 @@ impl InstOp {
 
     pub fn may_have_side_effect(&self) -> bool {
         match self {
-            InstOp::AsmBlock(_, _)
-            | InstOp::Call(..)
+            InstOp::AsmBlock(asm, _) => !asm.body.is_empty(),
+            InstOp::Call(..)
             | InstOp::ContractCall { .. }
             | InstOp::FuelVm(FuelVmInstruction::Log { .. })
             | InstOp::FuelVm(FuelVmInstruction::Smo { .. })
@@ -691,7 +696,11 @@ impl InstOp {
             InstOp::Branch(_)
                 | InstOp::ConditionalBranch { .. }
                 | InstOp::Ret(..)
-                | InstOp::FuelVm(FuelVmInstruction::Revert(..) | FuelVmInstruction::JmpMem)
+                | InstOp::FuelVm(
+                    FuelVmInstruction::Revert(..)
+                        | FuelVmInstruction::JmpMem
+                        | FuelVmInstruction::Retd { .. }
+                )
         )
     }
 }
@@ -831,7 +840,7 @@ impl<'a, 'eng> InstructionInserter<'a, 'eng> {
     // XXX Maybe these should return result, in case they get bad args?
     //
 
-    /// Append a new [`Instruction::AsmBlock`] from `args` and a `body`.
+    /// Append a new [InstOp::AsmBlock] from `args` and a `body`.
     pub fn asm_block(
         self,
         args: Vec<AsmArg>,
diff --git a/sway-ir/src/irtype.rs b/sway-ir/src/irtype.rs
index 3bca2ace003..1211c1da6fe 100644
--- a/sway-ir/src/irtype.rs
+++ b/sway-ir/src/irtype.rs
@@ -39,6 +39,7 @@ pub enum TypeContent {
     Struct(Vec<Type>),
     Slice,
     Pointer(Type),
+    TypedSlice(Type),
 }
 
 impl Type {
@@ -162,6 +163,11 @@ impl Type {
         Self::get_type(context, &TypeContent::Slice).expect("create_basic_types not called")
     }
 
+    /// Get typed slice type
+    pub fn get_typed_slice(context: &mut Context, item_ty: Type) -> Type {
+        Self::get_or_create_unique_type(context, TypeContent::TypedSlice(item_ty))
+    }
+
     /// Return a string representation of type, used for printing.
     pub fn as_string(&self, context: &Context) -> String {
         let sep_types_str = |agg_content: &Vec<Type>, sep: &str| {
@@ -190,6 +196,7 @@ impl Type {
                 format!("{{ {} }}", sep_types_str(agg, ", "))
             }
             TypeContent::Slice => "slice".into(),
+            TypeContent::TypedSlice(ty) => format!("__slice[{}]", ty.as_string(context)),
             TypeContent::Pointer(ty) => format!("ptr {}", ty.as_string(context)),
         }
     }
@@ -209,6 +216,9 @@ impl Type {
             (TypeContent::Array(l, llen), TypeContent::Array(r, rlen)) => {
                 llen == rlen && l.eq(context, r)
             }
+
+            (TypeContent::TypedSlice(l), TypeContent::TypedSlice(r)) => l.eq(context, r),
+
             (TypeContent::Struct(l), TypeContent::Struct(r))
             | (TypeContent::Union(l), TypeContent::Union(r)) => {
                 l.len() == r.len() && l.iter().zip(r.iter()).all(|(l, r)| l.eq(context, r))
@@ -451,6 +461,15 @@ impl Type {
         }
     }
 
+    /// Get the type of the array element, if applicable.
+    pub fn get_typed_slice_elem_type(&self, context: &Context) -> Option<Type> {
+        if let TypeContent::TypedSlice(ty) = *self.get_content(context) {
+            Some(ty)
+        } else {
+            None
+        }
+    }
+
     /// Get the length of the array , if applicable.
     pub fn get_array_len(&self, context: &Context) -> Option<u64> {
         if let TypeContent::Array(_, n) = *self.get_content(context) {
@@ -542,6 +561,7 @@ impl Type {
             TypeContent::Uint(256) => TypeSize::new(32),
             TypeContent::Uint(_) => unreachable!(),
             TypeContent::Slice => TypeSize::new(16),
+            TypeContent::TypedSlice(..) => TypeSize::new(16),
             TypeContent::B256 => TypeSize::new(32),
             TypeContent::StringSlice => TypeSize::new(16),
             TypeContent::StringArray(n) => {
diff --git a/sway-ir/src/module.rs b/sway-ir/src/module.rs
index fbeb6ab1c3b..8e37e6bf1b5 100644
--- a/sway-ir/src/module.rs
+++ b/sway-ir/src/module.rs
@@ -2,7 +2,10 @@
 //!
 //! A module also has a 'kind' corresponding to the different Sway module types.
 
-use std::collections::{BTreeMap, HashMap};
+use std::{
+    cell::Cell,
+    collections::{BTreeMap, HashMap},
+};
 
 use crate::{
     context::Context,
@@ -38,7 +41,7 @@ pub enum ConfigContent {
         ty: Type,
         ptr_ty: Type,
         encoded_bytes: Vec<u8>,
-        decode_fn: Function,
+        decode_fn: Cell<Function>,
         opt_metadata: Option<MetadataIndex>,
     },
 }
diff --git a/sway-ir/src/optimize.rs b/sway-ir/src/optimize.rs
index fa35752d116..564002fff13 100644
--- a/sway-ir/src/optimize.rs
+++ b/sway-ir/src/optimize.rs
@@ -19,6 +19,10 @@ pub mod const_demotion;
 pub use const_demotion::*;
 pub mod constants;
 pub use constants::*;
+pub mod conditional_constprop;
+pub use conditional_constprop::*;
+pub mod cse;
+pub use cse::*;
 pub mod dce;
 pub use dce::*;
 pub mod inline;
@@ -128,7 +132,7 @@ pub mod tests {
 
         for (actual, expected) in actual.iter().zip(expected) {
             if !actual.contains(expected) {
-                panic!("error: {actual:?} {expected:?}");
+                panic!("Actual: {actual:?} does not contains expected: {expected:?}. (Run with --nocapture to see a diff)");
             } else {
                 expected_matches -= 1;
             }
diff --git a/sway-ir/src/optimize/conditional_constprop.rs b/sway-ir/src/optimize/conditional_constprop.rs
new file mode 100644
index 00000000000..deb5a1b1623
--- /dev/null
+++ b/sway-ir/src/optimize/conditional_constprop.rs
@@ -0,0 +1,98 @@
+//! When a value is guaranteed to have a constant value in a region of the CFG,
+//! this optimization replaces uses of that value with the constant in that region.
+
+use rustc_hash::FxHashMap;
+
+use crate::{
+    AnalysisResults, Context, DomTree, Function, InstOp, Instruction, IrError, Pass,
+    PassMutability, Predicate, ScopedPass, DOMINATORS_NAME,
+};
+
+pub const CCP_NAME: &str = "ccp";
+
+pub fn create_ccp_pass() -> Pass {
+    Pass {
+        name: CCP_NAME,
+        descr: "Conditional constant proparagion",
+        deps: vec![DOMINATORS_NAME],
+        runner: ScopedPass::FunctionPass(PassMutability::Transform(ccp)),
+    }
+}
+
+pub fn ccp(
+    context: &mut Context,
+    analyses: &AnalysisResults,
+    function: Function,
+) -> Result<bool, IrError> {
+    let dom_tree: &DomTree = analyses.get_analysis_result(function);
+
+    // In the set of blocks dominated by `key`, replace all uses of `val.0` with `val.1`.
+    let mut dom_region_replacements = FxHashMap::default();
+
+    for block in function.block_iter(context) {
+        let term = block
+            .get_terminator(context)
+            .expect("Malformed block: no terminator");
+        if let InstOp::ConditionalBranch {
+            cond_value,
+            true_block,
+            false_block: _,
+        } = &term.op
+        {
+            if let Some(Instruction {
+                parent: _,
+                op: InstOp::Cmp(pred, v1, v2),
+            }) = cond_value.get_instruction(context)
+            {
+                if matches!(pred, Predicate::Equal)
+                    && (v1.is_constant(context) ^ v2.is_constant(context)
+                        && true_block.block.num_predecessors(context) == 1)
+                {
+                    if v1.is_constant(context) {
+                        dom_region_replacements.insert(true_block.block, (*v2, *v1));
+                    } else {
+                        dom_region_replacements.insert(true_block.block, (*v1, *v2));
+                    }
+                }
+            }
+        }
+    }
+
+    // lets walk the dominator tree from the root.
+    let root_block = function.get_entry_block(context);
+
+    if dom_region_replacements.is_empty() {
+        return Ok(false);
+    }
+
+    let mut stack = vec![(root_block, 0)];
+    let mut replacements = FxHashMap::default();
+    while let Some((block, next_child)) = stack.last().cloned() {
+        let cur_replacement_opt = dom_region_replacements.get(&block);
+
+        if next_child == 0 {
+            // Preorder processing
+            if let Some(cur_replacement) = cur_replacement_opt {
+                replacements.insert(cur_replacement.0, cur_replacement.1);
+            }
+            // walk the current block.
+            block.replace_values(context, &replacements);
+        }
+
+        // walk children.
+        if let Some(child) = dom_tree.child(block, next_child) {
+            // When we arrive back at "block" next time, we should process the next child.
+            stack.last_mut().unwrap().1 = next_child + 1;
+            // Go on to process the child.
+            stack.push((child, 0));
+        } else {
+            // No children left to process. Start postorder processing.
+            if let Some(cur_replacement) = cur_replacement_opt {
+                replacements.remove(&cur_replacement.0);
+            }
+            stack.pop();
+        }
+    }
+
+    Ok(true)
+}
diff --git a/sway-ir/src/optimize/constants.rs b/sway-ir/src/optimize/constants.rs
index 7c069c1c8f0..ec665bc1ff7 100644
--- a/sway-ir/src/optimize/constants.rs
+++ b/sway-ir/src/optimize/constants.rs
@@ -9,6 +9,7 @@ use crate::{
     value::ValueDatum,
     AnalysisResults, BranchToWithArgs, Instruction, Pass, PassMutability, Predicate, ScopedPass,
 };
+use rustc_hash::FxHashMap;
 
 pub const CONST_FOLDING_NAME: &str = "const-folding";
 
@@ -44,6 +45,11 @@ pub fn fold_constants(
             continue;
         }
 
+        if remove_useless_binary_op(context, &function) {
+            modified = true;
+            continue;
+        }
+
         if combine_unary_op(context, &function) {
             modified = true;
             continue;
@@ -241,6 +247,50 @@ fn combine_binary_op(context: &mut Context, function: &Function) -> bool {
     })
 }
 
+fn remove_useless_binary_op(context: &mut Context, function: &Function) -> bool {
+    let candidate =
+        function
+            .instruction_iter(context)
+            .find_map(
+                |(block, candidate)| match &context.values[candidate.0].value {
+                    ValueDatum::Instruction(Instruction {
+                        op: InstOp::BinaryOp { op, arg1, arg2 },
+                        ..
+                    }) if arg1.is_constant(context) || arg2.is_constant(context) => {
+                        let val1 = arg1.get_constant(context).map(|x| &x.value);
+                        let val2 = arg2.get_constant(context).map(|x| &x.value);
+
+                        use crate::BinaryOpKind::*;
+                        use ConstantValue::*;
+                        match (op, val1, val2) {
+                            // 0 + arg2
+                            (Add, Some(Uint(0)), _) => Some((block, candidate, *arg2)),
+                            // arg1 + 0
+                            (Add, _, Some(Uint(0))) => Some((block, candidate, *arg1)),
+                            // 1 * arg2
+                            (Mul, Some(Uint(1)), _) => Some((block, candidate, *arg2)),
+                            // arg1 * 1
+                            (Mul, _, Some(Uint(1))) => Some((block, candidate, *arg1)),
+                            // arg1 / 1
+                            (Div, _, Some(Uint(1))) => Some((block, candidate, *arg1)),
+                            // arg1 - 0
+                            (Sub, _, Some(Uint(0))) => Some((block, candidate, *arg1)),
+                            _ => None,
+                        }
+                    }
+                    _ => None,
+                },
+            );
+
+    candidate.map_or(false, |(block, old_value, new_value)| {
+        let replace_map = FxHashMap::from_iter([(old_value, new_value)]);
+        function.replace_values(context, &replace_map, None);
+
+        block.remove_instruction(context, old_value);
+        true
+    })
+}
+
 fn combine_unary_op(context: &mut Context, function: &Function) -> bool {
     let candidate = function
         .instruction_iter(context)
@@ -394,4 +444,31 @@ mod tests {
             Some(["const u64 6"]),
         );
     }
+
+    #[test]
+    fn ok_remove_useless_mul() {
+        assert_optimization(
+            &[CONST_FOLDING_NAME],
+            "entry fn main() -> u64 {
+                local u64 LOCAL
+            entry():
+                zero = const u64 0, !0
+                one = const u64 1, !0
+                l_ptr = get_local ptr u64, LOCAL, !0
+                l = load l_ptr, !0
+                result1 = mul l, one, !0
+                result2 = mul one, result1, !0
+                result3 = add result2, zero, !0
+                result4 = add zero, result3, !0
+                result5 = div result4, one, !0
+                result6 = sub result5, zero, !0
+                ret u64 result6, !0
+         }",
+            Some([
+                "v0 = get_local ptr u64, LOCAL",
+                "v1 = load v0",
+                "ret u64 v1",
+            ]),
+        );
+    }
 }
diff --git a/sway-ir/src/optimize/cse.rs b/sway-ir/src/optimize/cse.rs
new file mode 100644
index 00000000000..3eb03ac4ccb
--- /dev/null
+++ b/sway-ir/src/optimize/cse.rs
@@ -0,0 +1,408 @@
+//! Value numbering based common subexpression elimination.
+//! Reference: Value Driven Redundancy Elimination - Loren Taylor Simpson.
+
+use core::panic;
+use itertools::Itertools;
+use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
+use slotmap::Key;
+use std::{
+    collections::hash_map,
+    fmt::Debug,
+    hash::{Hash, Hasher},
+};
+
+use crate::{
+    AnalysisResults, BinaryOpKind, Context, DebugWithContext, DomTree, Function, InstOp, IrError,
+    Pass, PassMutability, PostOrder, Predicate, ScopedPass, Type, UnaryOpKind, Value,
+    DOMINATORS_NAME, POSTORDER_NAME,
+};
+
+pub const CSE_NAME: &str = "cse";
+
+pub fn create_cse_pass() -> Pass {
+    Pass {
+        name: CSE_NAME,
+        descr: "Common subexpression elimination",
+        runner: ScopedPass::FunctionPass(PassMutability::Transform(cse)),
+        deps: vec![POSTORDER_NAME, DOMINATORS_NAME],
+    }
+}
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, DebugWithContext)]
+enum ValueNumber {
+    // Top of the lattice = Don't know = uninitialized
+    Top,
+    // Belongs to a congruence class represented by the inner value.
+    Number(Value),
+}
+
+impl Debug for ValueNumber {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Top => write!(f, "Top"),
+            Self::Number(arg0) => write!(f, "v{:?}", arg0.0.data()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash, DebugWithContext)]
+enum Expr {
+    Phi(Vec<ValueNumber>),
+    UnaryOp {
+        op: UnaryOpKind,
+        arg: ValueNumber,
+    },
+    BinaryOp {
+        op: BinaryOpKind,
+        arg1: ValueNumber,
+        arg2: ValueNumber,
+    },
+    BitCast(ValueNumber, Type),
+    CastPtr(ValueNumber, Type),
+    Cmp(Predicate, ValueNumber, ValueNumber),
+    GetElemPtr {
+        base: ValueNumber,
+        elem_ptr_ty: Type,
+        indices: Vec<ValueNumber>,
+    },
+    IntToPtr(ValueNumber, Type),
+    PtrToInt(ValueNumber, Type),
+}
+
+/// Convert an instruction to an expression for hashing
+/// Instructions that we don't handle will have their value numbers be equal to themselves.
+fn instr_to_expr(context: &Context, vntable: &VNTable, instr: Value) -> Option<Expr> {
+    match &instr.get_instruction(context).unwrap().op {
+        InstOp::AsmBlock(_, _) => None,
+        InstOp::UnaryOp { op, arg } => Some(Expr::UnaryOp {
+            op: *op,
+            arg: vntable.value_map.get(arg).cloned().unwrap(),
+        }),
+        InstOp::BinaryOp { op, arg1, arg2 } => Some(Expr::BinaryOp {
+            op: *op,
+            arg1: vntable.value_map.get(arg1).cloned().unwrap(),
+            arg2: vntable.value_map.get(arg2).cloned().unwrap(),
+        }),
+        InstOp::BitCast(val, ty) => Some(Expr::BitCast(
+            vntable.value_map.get(val).cloned().unwrap(),
+            *ty,
+        )),
+        InstOp::Branch(_) => None,
+        InstOp::Call(_, _) => None,
+        InstOp::CastPtr(val, ty) => Some(Expr::CastPtr(
+            vntable.value_map.get(val).cloned().unwrap(),
+            *ty,
+        )),
+        InstOp::Cmp(pred, val1, val2) => Some(Expr::Cmp(
+            *pred,
+            vntable.value_map.get(val1).cloned().unwrap(),
+            vntable.value_map.get(val2).cloned().unwrap(),
+        )),
+        InstOp::ConditionalBranch { .. } => None,
+        InstOp::ContractCall { .. } => None,
+        InstOp::FuelVm(_) => None,
+        InstOp::GetLocal(_) => None,
+        InstOp::GetConfig(_, _) => None,
+        InstOp::GetElemPtr {
+            base,
+            elem_ptr_ty,
+            indices,
+        } => Some(Expr::GetElemPtr {
+            base: vntable.value_map.get(base).cloned().unwrap(),
+            elem_ptr_ty: *elem_ptr_ty,
+            indices: indices
+                .iter()
+                .map(|idx| vntable.value_map.get(idx).cloned().unwrap())
+                .collect(),
+        }),
+        InstOp::IntToPtr(val, ty) => Some(Expr::IntToPtr(
+            vntable.value_map.get(val).cloned().unwrap(),
+            *ty,
+        )),
+        InstOp::Load(_) => None,
+        InstOp::MemCopyBytes { .. } => None,
+        InstOp::MemCopyVal { .. } => None,
+        InstOp::Nop => None,
+        InstOp::PtrToInt(val, ty) => Some(Expr::PtrToInt(
+            vntable.value_map.get(val).cloned().unwrap(),
+            *ty,
+        )),
+        InstOp::Ret(_, _) => None,
+        InstOp::Store { .. } => None,
+    }
+}
+
+/// Convert a PHI argument to Expr
+fn phi_to_expr(context: &Context, vntable: &VNTable, phi_arg: Value) -> Expr {
+    let phi_arg = phi_arg.get_argument(context).unwrap();
+    let phi_args = phi_arg
+        .block
+        .pred_iter(context)
+        .map(|pred| {
+            let incoming_val = phi_arg
+                .get_val_coming_from(context, pred)
+                .expect("No parameter from predecessor");
+            vntable.value_map.get(&incoming_val).cloned().unwrap()
+        })
+        .collect();
+    Expr::Phi(phi_args)
+}
+
+#[derive(Default)]
+struct VNTable {
+    value_map: FxHashMap<Value, ValueNumber>,
+    expr_map: FxHashMap<Expr, ValueNumber>,
+}
+
+impl Debug for VNTable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "value_map:")?;
+        self.value_map.iter().for_each(|(key, value)| {
+            if format!("v{:?}", key.0.data()) == "v620v3" {
+                writeln!(f, "\tv{:?} -> {:?}", key.0.data(), value).expect("writeln! failed");
+            }
+        });
+        Ok(())
+    }
+}
+
+/// Wrapper around [DomTree::dominates] to work at instruction level.
+/// Does `inst1` dominate `inst2` ?
+fn dominates(context: &Context, dom_tree: &DomTree, inst1: Value, inst2: Value) -> bool {
+    let block1 = match &context.values[inst1.0].value {
+        crate::ValueDatum::Argument(arg) => arg.block,
+        crate::ValueDatum::Constant(_) => {
+            panic!("Shouldn't be querying dominance info for constants")
+        }
+        crate::ValueDatum::Instruction(i) => i.parent,
+    };
+    let block2 = match &context.values[inst2.0].value {
+        crate::ValueDatum::Argument(arg) => arg.block,
+        crate::ValueDatum::Constant(_) => {
+            panic!("Shouldn't be querying dominance info for constants")
+        }
+        crate::ValueDatum::Instruction(i) => i.parent,
+    };
+
+    if block1 == block2 {
+        let inst1_idx = block1
+            .instruction_iter(context)
+            .position(|inst| inst == inst1)
+            // Not found indicates a block argument
+            .unwrap_or(0);
+        let inst2_idx = block1
+            .instruction_iter(context)
+            .position(|inst| inst == inst2)
+            // Not found indicates a block argument
+            .unwrap_or(0);
+        inst1_idx < inst2_idx
+    } else {
+        dom_tree.dominates(block1, block2)
+    }
+}
+
+pub fn cse(
+    context: &mut Context,
+    analyses: &AnalysisResults,
+    function: Function,
+) -> Result<bool, IrError> {
+    let mut vntable = VNTable::default();
+
+    // Function arg values map to themselves.
+    for arg in function.args_iter(context) {
+        vntable.value_map.insert(arg.1, ValueNumber::Number(arg.1));
+    }
+
+    // Map all other arg values map to Top.
+    for block in function.block_iter(context).skip(1) {
+        for arg in block.arg_iter(context) {
+            vntable.value_map.insert(*arg, ValueNumber::Top);
+        }
+    }
+
+    // Initialize all instructions and constants. Constants need special treatment.
+    // They don't have PartialEq implemented. So we need to value number them manually.
+    // This map maps the hash of a constant value to all possible collisions of it.
+    let mut const_map = FxHashMap::<u64, Vec<Value>>::default();
+    for (_, inst) in function.instruction_iter(context) {
+        vntable.value_map.insert(inst, ValueNumber::Top);
+        for (const_opd_val, const_opd_const) in inst
+            .get_instruction(context)
+            .unwrap()
+            .op
+            .get_operands()
+            .iter()
+            .filter_map(|opd| opd.get_constant(context).map(|copd| (opd, copd)))
+        {
+            let mut state = FxHasher::default();
+            const_opd_const.hash(&mut state);
+            let hash = state.finish();
+            if let Some(existing_const) = const_map.get(&hash).and_then(|consts| {
+                consts.iter().find(|val| {
+                    let c = val
+                        .get_constant(context)
+                        .expect("const_map can only contain consts");
+                    const_opd_const.eq(context, c)
+                })
+            }) {
+                vntable
+                    .value_map
+                    .insert(*const_opd_val, ValueNumber::Number(*existing_const));
+            } else {
+                const_map
+                    .entry(hash)
+                    .and_modify(|consts| consts.push(*const_opd_val))
+                    .or_insert_with(|| vec![*const_opd_val]);
+                vntable
+                    .value_map
+                    .insert(*const_opd_val, ValueNumber::Number(*const_opd_val));
+            }
+        }
+    }
+
+    // We need to iterate over the blocks in RPO.
+    let post_order: &PostOrder = analyses.get_analysis_result(function);
+
+    // RPO based value number (Sec 4.2).
+    let mut changed = true;
+    while changed {
+        changed = false;
+        // For each block in RPO:
+        for (block_idx, block) in post_order.po_to_block.iter().rev().enumerate() {
+            // Process PHIs and then the other instructions.
+            if block_idx != 0 {
+                // Entry block arguments are not PHIs.
+                for (phi, expr_opt) in block
+                    .arg_iter(context)
+                    .map(|arg| (*arg, Some(phi_to_expr(context, &vntable, *arg))))
+                    .collect_vec()
+                {
+                    let expr = expr_opt.expect("PHIs must always translate to a valid Expr");
+                    // We first try to see if PHIs can be simplified into a single value.
+                    let vn = {
+                        let Expr::Phi(ref phi_args) = expr else {
+                            panic!("Expr must be a PHI")
+                        };
+                        phi_args
+                            .iter()
+                            .map(|vn| Some(*vn))
+                            .reduce(|vn1, vn2| {
+                                // Here `None` indicates Bottom of the lattice.
+                                if let (Some(vn1), Some(vn2)) = (vn1, vn2) {
+                                    match (vn1, vn2) {
+                                        (ValueNumber::Top, ValueNumber::Top) => {
+                                            Some(ValueNumber::Top)
+                                        }
+                                        (ValueNumber::Top, ValueNumber::Number(vn))
+                                        | (ValueNumber::Number(vn), ValueNumber::Top) => {
+                                            Some(ValueNumber::Number(vn))
+                                        }
+                                        (ValueNumber::Number(vn1), ValueNumber::Number(vn2)) => {
+                                            (vn1 == vn2).then_some(ValueNumber::Number(vn1))
+                                        }
+                                    }
+                                } else {
+                                    None
+                                }
+                            })
+                            .flatten()
+                            // The PHI couldn't be simplified to a single ValueNumber.
+                            .unwrap_or(ValueNumber::Number(phi))
+                    };
+
+                    match vntable.value_map.entry(phi) {
+                        hash_map::Entry::Occupied(occ) if *occ.get() == vn => {}
+                        _ => {
+                            changed = true;
+                            vntable.value_map.insert(phi, vn);
+                        }
+                    }
+                }
+            }
+
+            for (inst, expr_opt) in block
+                .instruction_iter(context)
+                .map(|instr| (instr, instr_to_expr(context, &vntable, instr)))
+                .collect_vec()
+            {
+                // lookup(expr, x)
+                let vn = if let Some(expr) = expr_opt {
+                    match vntable.expr_map.entry(expr) {
+                        hash_map::Entry::Occupied(occ) => *occ.get(),
+                        hash_map::Entry::Vacant(vac) => *(vac.insert(ValueNumber::Number(inst))),
+                    }
+                } else {
+                    // Instructions that always map to their own value number
+                    // (i.e., they can never be equal to some other instruction).
+                    ValueNumber::Number(inst)
+                };
+                match vntable.value_map.entry(inst) {
+                    hash_map::Entry::Occupied(occ) if *occ.get() == vn => {}
+                    _ => {
+                        changed = true;
+                        vntable.value_map.insert(inst, vn);
+                    }
+                }
+            }
+        }
+        vntable.expr_map.clear();
+    }
+
+    // create a partition of congruent (equal) values.
+    let mut partition = FxHashMap::<ValueNumber, FxHashSet<Value>>::default();
+    vntable.value_map.iter().for_each(|(v, vn)| {
+        // If v is a constant or its value number is itself, don't add to the partition.
+        // The latter condition is so that we have only > 1 sized partitions.
+        if v.is_constant(context)
+            || matches!(vn, ValueNumber::Top)
+            || matches!(vn, ValueNumber::Number(v2) if (v == v2 || v2.is_constant(context)))
+        {
+            return;
+        }
+        partition
+            .entry(*vn)
+            .and_modify(|part| {
+                part.insert(*v);
+            })
+            .or_insert(vec![*v].into_iter().collect());
+    });
+
+    // For convenience, now add back back `v` into `partition[VN[v]]` if it isn't already there.
+    partition.iter_mut().for_each(|(vn, v_part)| {
+        let ValueNumber::Number(v) = vn else {
+            panic!("We cannot have Top at this point");
+        };
+        v_part.insert(*v);
+        assert!(
+            v_part.len() > 1,
+            "We've only created partitions with size greater than 1"
+        );
+    });
+
+    // There are two ways to replace congruent values (see the paper cited, Sec 5).
+    // 1. Dominator based. If v1 and v2 are equal, v1 dominates v2, we just remove v2
+    // and replace its uses with v1. Simple, and what we're going to do.
+    // 2. AVAIL based. More powerful, but also requires a data-flow-analysis for AVAIL
+    // and later on, mem2reg again since replacements will need breaking SSA.
+    let dom_tree: &DomTree = analyses.get_analysis_result(function);
+    let mut replace_map = FxHashMap::<Value, Value>::default();
+    let mut modified = false;
+    // Check every set in the partition.
+    partition.iter().for_each(|(_leader, vals)| {
+        // Iterate over every pair of values, checking if one can replace the other.
+        for v_pair in vals.iter().combinations(2) {
+            let (v1, v2) = (*v_pair[0], *v_pair[1]);
+            if dominates(context, dom_tree, v1, v2) {
+                modified = true;
+                replace_map.insert(v2, v1);
+            } else if dominates(context, dom_tree, v2, v1) {
+                modified = true;
+                replace_map.insert(v1, v2);
+            }
+        }
+    });
+
+    function.replace_values(context, &replace_map, None);
+
+    Ok(modified)
+}
diff --git a/sway-ir/src/optimize/dce.rs b/sway-ir/src/optimize/dce.rs
index be1fb06509f..7883a8b74bc 100644
--- a/sway-ir/src/optimize/dce.rs
+++ b/sway-ir/src/optimize/dce.rs
@@ -1,10 +1,12 @@
 //! ## Dead Code Elimination
 //!
-//! This optimization removes unused definitions. The pass is a combination of
+//! This optimization removes unused definitions. The pass is a combination of:
 //!   1. A liveness analysis that keeps track of the uses of a definition,
 //!   2. At the time of inspecting a definition, if it has no uses, it is removed.
-//! This pass does not do CFG transformations. That is handled by simplify_cfg.
+//!
+//! This pass does not do CFG transformations. That is handled by `simplify_cfg`.
 
+use itertools::Itertools;
 use rustc_hash::FxHashSet;
 
 use crate::{
@@ -37,23 +39,36 @@ pub fn create_fn_dce_pass() -> Pass {
     }
 }
 
-fn can_eliminate_instruction(
+fn can_eliminate_value(
     context: &Context,
     val: Value,
-    num_symbol_uses: &HashMap<Symbol, u32>,
+    num_symbol_loaded: &NumSymbolLoaded,
     escaped_symbols: &EscapedSymbols,
 ) -> bool {
-    let inst = val.get_instruction(context).unwrap();
+    let Some(inst) = val.get_instruction(context) else {
+        return true;
+    };
+
     (!inst.op.is_terminator() && !inst.op.may_have_side_effect())
-        || is_removable_store(context, val, num_symbol_uses, escaped_symbols)
+        || is_removable_store(context, val, num_symbol_loaded, escaped_symbols)
 }
 
 fn is_removable_store(
     context: &Context,
     val: Value,
-    num_symbol_uses: &HashMap<Symbol, u32>,
+    num_symbol_loaded: &NumSymbolLoaded,
     escaped_symbols: &EscapedSymbols,
 ) -> bool {
+    let escaped_symbols = match escaped_symbols {
+        EscapedSymbols::Complete(syms) => syms,
+        EscapedSymbols::Incomplete(_) => return false,
+    };
+
+    let num_symbol_loaded = match num_symbol_loaded {
+        NumSymbolLoaded::Unknown => return false,
+        NumSymbolLoaded::Known(known_num_symbol_loaded) => known_num_symbol_loaded,
+    };
+
     match val.get_instruction(context).unwrap().op {
         InstOp::MemCopyBytes { dst_val_ptr, .. }
         | InstOp::MemCopyVal { dst_val_ptr, .. }
@@ -62,7 +77,7 @@ fn is_removable_store(
             match syms {
                 ReferredSymbols::Complete(syms) => syms.iter().all(|sym| {
                     !escaped_symbols.contains(sym)
-                        && num_symbol_uses.get(sym).map_or(0, |uses| *uses) == 0
+                        && num_symbol_loaded.get(sym).map_or(0, |uses| *uses) == 0
                 }),
                 // We cannot guarantee that the destination is not used.
                 ReferredSymbols::Incomplete(_) => false,
@@ -72,48 +87,110 @@ fn is_removable_store(
     }
 }
 
-/// Perform dead code (if any) elimination and return true if function is modified.
+/// How many times a [Symbol] gets loaded from, directly or indirectly.
+/// This number is either exactly `Known` for all the symbols loaded from, or is
+/// considered to be `Unknown` for all the symbols.
+enum NumSymbolLoaded {
+    Unknown,
+    Known(HashMap<Symbol, u32>),
+}
+
+/// Instructions that store to a [Symbol], directly or indirectly.
+/// These instructions are either exactly `Known` for all the symbols stored to, or is
+/// considered to be `Unknown` for all the symbols.
+enum StoresOfSymbol {
+    Unknown,
+    Known(HashMap<Symbol, Vec<Value>>),
+}
+
+fn get_operands(value: Value, context: &Context) -> Vec<Value> {
+    if let Some(inst) = value.get_instruction(context) {
+        inst.op.get_operands()
+    } else if let Some(arg) = value.get_argument(context) {
+        arg.block
+            .pred_iter(context)
+            .map(|pred| {
+                arg.get_val_coming_from(context, pred)
+                    .expect("Block arg doesn't have value passed from predecessor")
+            })
+            .collect()
+    } else {
+        vec![]
+    }
+}
+
+/// Perform dead code (if any) elimination and return true if the `function` is modified.
 pub fn dce(
     context: &mut Context,
     analyses: &AnalysisResults,
     function: Function,
 ) -> Result<bool, IrError> {
+    // For DCE, we need to proceed with the analysis even if we have
+    // incomplete list of escaped symbols, because we could have
+    // unused instructions in code. Removing unused instructions is
+    // independent of having any escaping symbols.
     let escaped_symbols: &EscapedSymbols = analyses.get_analysis_result(function);
 
-    // Number of uses that an instruction has.
-    let mut num_uses: HashMap<Value, u32> = HashMap::new();
+    // Number of uses that an instruction / block arg has. This number is always known.
+    let mut num_ssa_uses: HashMap<Value, u32> = HashMap::new();
+    // Number of times a local is accessed via `get_local`. This number is always known.
     let mut num_local_uses: HashMap<LocalVar, u32> = HashMap::new();
-    let mut num_symbol_uses: HashMap<Symbol, u32> = HashMap::new();
-    let mut stores_of_sym: HashMap<Symbol, Vec<Value>> = HashMap::new();
+    // Number of times a symbol, local or a function argument, is loaded, directly or indirectly. This number can be unknown.
+    let mut num_symbol_loaded: NumSymbolLoaded = NumSymbolLoaded::Known(HashMap::new());
+    // Instructions that store to a symbol, directly or indirectly. This information can be unknown.
+    let mut stores_of_sym: StoresOfSymbol = StoresOfSymbol::Known(HashMap::new());
 
+    // TODO-IG: Update this logic once `mut arg: T`s are implemented.
+    //          Currently, only `ref mut arg` arguments can be stored to,
+    //          which means they can be loaded from the caller.
+    //          Once we support `mut arg` in general, this will not be
+    //          the case anymore and we will need to distinguish between
+    //          `mut arg: T`, `arg: &mut T`, etc.
     // Every argument is assumed to be loaded from (from the caller),
     // so stores to it shouldn't be eliminated.
-    for sym in function
-        .args_iter(context)
-        .flat_map(|arg| get_gep_referred_symbols(context, arg.1))
-    {
-        num_symbol_uses
-            .entry(sym)
-            .and_modify(|count| *count += 1)
-            .or_insert(1);
-    }
-
-    // Go through each instruction and update use_count.
-    for (_block, inst) in function.instruction_iter(context) {
-        for sym in memory_utils::get_loaded_symbols(context, inst) {
-            num_symbol_uses
+    if let NumSymbolLoaded::Known(known_num_symbol_loaded) = &mut num_symbol_loaded {
+        for sym in function
+            .args_iter(context)
+            .flat_map(|arg| get_gep_referred_symbols(context, arg.1))
+        {
+            known_num_symbol_loaded
                 .entry(sym)
                 .and_modify(|count| *count += 1)
                 .or_insert(1);
         }
+    }
+
+    // Go through each instruction and update use counters.
+    for (_block, inst) in function.instruction_iter(context) {
+        if let NumSymbolLoaded::Known(known_num_symbol_loaded) = &mut num_symbol_loaded {
+            match memory_utils::get_loaded_symbols(context, inst) {
+                ReferredSymbols::Complete(loaded_symbols) => {
+                    for sym in loaded_symbols {
+                        known_num_symbol_loaded
+                            .entry(sym)
+                            .and_modify(|count| *count += 1)
+                            .or_insert(1);
+                    }
+                }
+                ReferredSymbols::Incomplete(_) => num_symbol_loaded = NumSymbolLoaded::Unknown,
+            }
+        }
 
-        for stored_sym in memory_utils::get_stored_symbols(context, inst) {
-            stores_of_sym
-                .entry(stored_sym)
-                .and_modify(|stores| stores.push(inst))
-                .or_insert(vec![inst]);
+        if let StoresOfSymbol::Known(known_stores_of_sym) = &mut stores_of_sym {
+            match memory_utils::get_stored_symbols(context, inst) {
+                ReferredSymbols::Complete(stored_symbols) => {
+                    for stored_sym in stored_symbols {
+                        known_stores_of_sym
+                            .entry(stored_sym)
+                            .and_modify(|stores| stores.push(inst))
+                            .or_insert(vec![inst]);
+                    }
+                }
+                ReferredSymbols::Incomplete(_) => stores_of_sym = StoresOfSymbol::Unknown,
+            }
         }
 
+        // A local is used if it is accessed via `get_local`.
         let inst = inst.get_instruction(context).unwrap();
         if let InstOp::GetLocal(local) = inst.op {
             num_local_uses
@@ -121,61 +198,92 @@ pub fn dce(
                 .and_modify(|count| *count += 1)
                 .or_insert(1);
         }
+
+        // An instruction or block-arg is used if it is an operand in another instruction.
         let opds = inst.op.get_operands();
-        for v in opds {
-            match context.values[v.0].value {
-                ValueDatum::Instruction(_) => {
-                    num_uses
-                        .entry(v)
+        for opd in opds {
+            match context.values[opd.0].value {
+                ValueDatum::Instruction(_) | ValueDatum::Argument(_) => {
+                    num_ssa_uses
+                        .entry(opd)
                         .and_modify(|count| *count += 1)
                         .or_insert(1);
                 }
-                ValueDatum::Constant(_) | ValueDatum::Argument(_) => {}
+                ValueDatum::Constant(_) => {}
             }
         }
     }
 
+    // The list of all unused or `Store` instruction. Note that the `Store` instruction does
+    // not result in a value, and will, thus, always be treated as unused and will not
+    // have an entry in `num_inst_uses`. So, to collect unused or `Store` instructions it
+    // is sufficient to filter those that are not used.
     let mut worklist = function
         .instruction_iter(context)
-        .filter_map(|(_block, inst)| {
-            (num_uses.get(&inst).is_none()
-                || is_removable_store(context, inst, &num_symbol_uses, escaped_symbols))
-            .then_some(inst)
-        })
+        .filter_map(|(_, inst)| (!num_ssa_uses.contains_key(&inst)).then_some(inst))
         .collect::<Vec<_>>();
+    let dead_args = function
+        .block_iter(context)
+        .flat_map(|block| {
+            block
+                .arg_iter(context)
+                .filter_map(|arg| (!num_ssa_uses.contains_key(arg)).then_some(*arg))
+                .collect_vec()
+        })
+        .collect_vec();
+    worklist.extend(dead_args);
 
     let mut modified = false;
     let mut cemetery = FxHashSet::default();
     while let Some(dead) = worklist.pop() {
-        if !can_eliminate_instruction(context, dead, &num_symbol_uses, escaped_symbols)
+        if !can_eliminate_value(context, dead, &num_symbol_loaded, escaped_symbols)
             || cemetery.contains(&dead)
         {
             continue;
         }
         // Process dead's operands.
-        let opds = dead.get_instruction(context).unwrap().op.get_operands();
-        for v in opds {
-            // Reduce the use count of v. If it reaches 0, add it to the worklist.
-            match context.values[v.0].value {
-                ValueDatum::Instruction(_) => {
-                    let nu = num_uses.get_mut(&v).unwrap();
+        let opds = get_operands(dead, context);
+        for opd in opds {
+            // Reduce the use count of the operand used in the dead instruction.
+            // If it reaches 0, add it to the worklist, since it is not used
+            // anywhere else.
+            match context.values[opd.0].value {
+                ValueDatum::Instruction(_) | ValueDatum::Argument(_) => {
+                    let nu = num_ssa_uses.get_mut(&opd).unwrap();
                     *nu -= 1;
                     if *nu == 0 {
-                        worklist.push(v);
+                        worklist.push(opd);
                     }
                 }
-                ValueDatum::Constant(_) | ValueDatum::Argument(_) => {}
+                ValueDatum::Constant(_) => {}
             }
         }
-        for sym in memory_utils::get_loaded_symbols(context, dead) {
-            let nu = num_symbol_uses.get_mut(&sym).unwrap();
-            *nu -= 1;
-            if *nu == 0 {
-                for store in stores_of_sym.get(&sym).unwrap_or(&vec![]) {
-                    worklist.push(*store);
+
+        if dead.get_instruction(context).is_some() {
+            // If the `dead` instruction was the only instruction loading from a `sym`bol,
+            // after removing it, there will be no loads anymore, so all the stores to
+            // that `sym`bol can be added to the worklist.
+            if let ReferredSymbols::Complete(loaded_symbols) =
+                memory_utils::get_loaded_symbols(context, dead)
+            {
+                if let (
+                    NumSymbolLoaded::Known(known_num_symbol_loaded),
+                    StoresOfSymbol::Known(known_stores_of_sym),
+                ) = (&mut num_symbol_loaded, &mut stores_of_sym)
+                {
+                    for sym in loaded_symbols {
+                        let nu = known_num_symbol_loaded.get_mut(&sym).unwrap();
+                        *nu -= 1;
+                        if *nu == 0 {
+                            for store in known_stores_of_sym.get(&sym).unwrap_or(&vec![]) {
+                                worklist.push(*store);
+                            }
+                        }
+                    }
                 }
             }
         }
+
         cemetery.insert(dead);
 
         if let ValueDatum::Instruction(Instruction {
@@ -186,11 +294,44 @@ pub fn dce(
             let count = num_local_uses.get_mut(&local).unwrap();
             *count -= 1;
         }
+
         modified = true;
     }
 
-    // Remove all dead instructions.
-    for block in function.block_iter(context) {
+    // Remove all dead instructions and arguments.
+    // We collect here and below because we want &mut Context for modifications.
+    for block in function.block_iter(context).collect_vec() {
+        if block != function.get_entry_block(context) {
+            // dead_args[arg_idx] indicates whether the argument is dead.
+            let dead_args = block
+                .arg_iter(context)
+                .map(|arg| cemetery.contains(arg))
+                .collect_vec();
+            for pred in block.pred_iter(context).cloned().collect_vec() {
+                let params = pred
+                    .get_succ_params_mut(context, &block)
+                    .expect("Invalid IR");
+                let mut index = 0;
+                // Remove parameters passed to a dead argument.
+                params.retain(|_| {
+                    let retain = !dead_args[index];
+                    index += 1;
+                    retain
+                });
+            }
+            // Remove the dead argument itself.
+            let mut index = 0;
+            context.blocks[block.0].args.retain(|_| {
+                let retain = !dead_args[index];
+                index += 1;
+                retain
+            });
+            // Update the self-index stored in each arg.
+            for (arg_idx, arg) in block.arg_iter(context).cloned().enumerate().collect_vec() {
+                let arg = arg.get_argument_mut(context).unwrap();
+                arg.idx = arg_idx;
+            }
+        }
         block.remove_instructions(context, |inst| cemetery.contains(&inst));
     }
 
@@ -219,7 +360,7 @@ pub fn fn_dce(context: &mut Context, _: &AnalysisResults, module: Module) -> Res
     // config decode fns
     for config in context.modules[module.0].configs.iter() {
         if let crate::ConfigContent::V1 { decode_fn, .. } = config.1 {
-            grow_called_function_set(context, *decode_fn, &mut called_fns);
+            grow_called_function_set(context, decode_fn.get(), &mut called_fns);
         }
     }
 
diff --git a/sway-ir/src/optimize/fn_dedup.rs b/sway-ir/src/optimize/fn_dedup.rs
index 257db379a72..c53aef4cb43 100644
--- a/sway-ir/src/optimize/fn_dedup.rs
+++ b/sway-ir/src/optimize/fn_dedup.rs
@@ -286,6 +286,9 @@ pub fn dedup_fns(
         hash_set_map: FxHashMap::default(),
         function_hash_map: FxHashMap::default(),
     };
+
+    let mut dups_to_delete = vec![];
+
     let cg = build_call_graph(context, &context.modules.get(module.0).unwrap().functions);
     let callee_first = callee_first_order(&cg);
     for function in callee_first {
@@ -324,6 +327,7 @@ pub fn dedup_fns(
             else {
                 continue;
             };
+            dups_to_delete.push(*callee);
             replacements.push((inst, args.clone(), callee_rep));
         }
         if !replacements.is_empty() {
@@ -340,6 +344,35 @@ pub fn dedup_fns(
         }
     }
 
+    // Replace config decode fns
+    for config in module.iter_configs(context) {
+        if let crate::ConfigContent::V1 { decode_fn, .. } = config {
+            let f = decode_fn.get();
+
+            let Some(callee_hash) = eq_class.function_hash_map.get(&f) else {
+                continue;
+            };
+
+            // If the representative (first element in the set) is different, we need to replace.
+            let Some(callee_rep) = eq_class
+                .hash_set_map
+                .get(callee_hash)
+                .and_then(|f| f.iter().next())
+                .filter(|rep| *rep != &f)
+            else {
+                continue;
+            };
+
+            dups_to_delete.push(decode_fn.get());
+            decode_fn.replace(*callee_rep);
+        }
+    }
+
+    // Remove replaced functions
+    for function in dups_to_delete {
+        module.remove_function(context, &function);
+    }
+
     Ok(modified)
 }
 
diff --git a/sway-ir/src/optimize/inline.rs b/sway-ir/src/optimize/inline.rs
index e396cc90df7..0c0fbf39485 100644
--- a/sway-ir/src/optimize/inline.rs
+++ b/sway-ir/src/optimize/inline.rs
@@ -35,12 +35,12 @@ pub fn create_fn_inline_pass() -> Pass {
 /// This is a copy of sway_core::inline::Inline.
 /// TODO: Reuse: Depend on sway_core? Move it to sway_types?
 #[derive(Debug)]
-enum Inline {
+pub enum Inline {
     Always,
     Never,
 }
 
-fn metadata_to_inline(context: &Context, md_idx: Option<MetadataIndex>) -> Option<Inline> {
+pub fn metadata_to_inline(context: &Context, md_idx: Option<MetadataIndex>) -> Option<Inline> {
     fn for_each_md_idx<T, F: FnMut(MetadataIndex) -> Option<T>>(
         context: &Context,
         md_idx: Option<MetadataIndex>,
@@ -98,6 +98,14 @@ pub fn fn_inline(
             });
 
     let inline_heuristic = |ctx: &Context, func: &Function, _call_site: &Value| {
+        // The encoding code in the `__entry` functions contains pointer patterns that mark
+        // escape analysis and referred symbols as incomplete. This effectively forbids optimizations
+        // like SROA nad DCE. If we inline original entries, like e.g., `main`, the code in them will
+        // also not be optimized. Therefore, we forbid inlining of original entries into `__entry`.
+        if func.is_original_entry(ctx) {
+            return false;
+        }
+
         let attributed_inline = metadata_to_inline(ctx, func.get_metadata(ctx));
         match attributed_inline {
             Some(Inline::Always) => {
@@ -117,7 +125,7 @@ pub fn fn_inline(
 
         // If the function is (still) small then also inline it.
         const MAX_INLINE_INSTRS_COUNT: usize = 4;
-        if func.num_instructions(ctx) <= MAX_INLINE_INSTRS_COUNT {
+        if func.num_instructions_incl_asm_instructions(ctx) <= MAX_INLINE_INSTRS_COUNT {
             return true;
         }
 
@@ -181,6 +189,12 @@ pub fn inline_some_function_calls<F: Fn(&Context, &Function, &Value) -> bool>(
     for call_site in &call_sites {
         let call_site_in = call_data.get(call_site).unwrap();
         let (block, inlined_function) = *call_site_in.borrow();
+
+        if function == &inlined_function {
+            // We can't inline a function into itself.
+            continue;
+        }
+
         inline_function_call(
             context,
             *function,
@@ -231,7 +245,7 @@ pub fn is_small_fn(
         max_blocks.map_or(true, |max_block_count| {
             function.num_blocks(context) <= max_block_count
         }) && max_instrs.map_or(true, |max_instrs_count| {
-            function.num_instructions(context) <= max_instrs_count
+            function.num_instructions_incl_asm_instructions(context) <= max_instrs_count
         }) && max_stack_size.map_or(true, |max_stack_size_count| {
             function
                 .locals_iter(context)
diff --git a/sway-ir/src/optimize/mem2reg.rs b/sway-ir/src/optimize/mem2reg.rs
index 0a3484cec4a..c7c8a5b847b 100644
--- a/sway-ir/src/optimize/mem2reg.rs
+++ b/sway-ir/src/optimize/mem2reg.rs
@@ -319,12 +319,12 @@ pub fn promote_to_registers(
         }
 
         // Process dominator children.
-        for child in dom_tree[&node].children.iter() {
+        for child in dom_tree.children(node) {
             record_rewrites(
                 context,
                 function,
                 dom_tree,
-                *child,
+                child,
                 safe_locals,
                 phi_to_local,
                 name_stack,
diff --git a/sway-ir/src/optimize/memcpyopt.rs b/sway-ir/src/optimize/memcpyopt.rs
index c88b0340e7f..265db81695b 100644
--- a/sway-ir/src/optimize/memcpyopt.rs
+++ b/sway-ir/src/optimize/memcpyopt.rs
@@ -6,10 +6,10 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use sway_types::{FxIndexMap, FxIndexSet};
 
 use crate::{
-    get_gep_referred_symbols, get_gep_symbol, get_referred_symbol, get_referred_symbols,
-    memory_utils, AnalysisResults, Block, Context, EscapedSymbols, Function, InstOp, Instruction,
-    IrError, LocalVar, Pass, PassMutability, ScopedPass, Symbol, Type, Value, ValueDatum,
-    ESCAPED_SYMBOLS_NAME,
+    get_gep_symbol, get_referred_symbol, get_referred_symbols, get_stored_symbols, memory_utils,
+    AnalysisResults, Block, Context, EscapedSymbols, FuelVmInstruction, Function, InstOp,
+    Instruction, InstructionInserter, IrError, LocalVar, Pass, PassMutability, ReferredSymbols,
+    ScopedPass, Symbol, Type, Value, ValueDatum, ESCAPED_SYMBOLS_NAME,
 };
 
 pub const MEMCPYOPT_NAME: &str = "memcpyopt";
@@ -29,14 +29,18 @@ pub fn mem_copy_opt(
     function: Function,
 ) -> Result<bool, IrError> {
     let mut modified = false;
-    modified |= local_copy_prop_prememcpy(context, function)?;
+    modified |= local_copy_prop_prememcpy(context, analyses, function)?;
     modified |= load_store_to_memcopy(context, function)?;
     modified |= local_copy_prop(context, analyses, function)?;
 
     Ok(modified)
 }
 
-fn local_copy_prop_prememcpy(context: &mut Context, function: Function) -> Result<bool, IrError> {
+fn local_copy_prop_prememcpy(
+    context: &mut Context,
+    analyses: &AnalysisResults,
+    function: Function,
+) -> Result<bool, IrError> {
     struct InstInfo {
         // The block containing the instruction.
         block: Block,
@@ -44,20 +48,19 @@ fn local_copy_prop_prememcpy(context: &mut Context, function: Function) -> Resul
         pos: usize,
     }
 
+    // If the analysis result is incomplete we cannot do any safe optimizations here.
+    // Calculating the candidates below relies on complete result of an escape analysis.
+    let escaped_symbols = match analyses.get_analysis_result(function) {
+        EscapedSymbols::Complete(syms) => syms,
+        EscapedSymbols::Incomplete(_) => return Ok(false),
+    };
+
     // All instructions that load from the `Symbol`.
     let mut loads_map = FxHashMap::<Symbol, Vec<Value>>::default();
     // All instructions that store to the `Symbol`.
     let mut stores_map = FxHashMap::<Symbol, Vec<Value>>::default();
     // All load and store instructions.
     let mut instr_info_map = FxHashMap::<Value, InstInfo>::default();
-    // Symbols that escape.
-    // TODO: The below code does its own logic to calculate escaping symbols.
-    //       It does not cover all escaping cases, though. E.g., contract calls, etc.
-    //       In general, the question is why it does not use `memory_utils::compute_escaped_symbols`.
-    //       My assumption is that it was written before `memory_utils::compute_escaped_symbols`
-    //       got available.
-    //       See: https://github.com/FuelLabs/sway/issues/5924
-    let mut escaping_uses = FxHashSet::<Symbol>::default();
 
     for (pos, (block, inst)) in function.instruction_iter(context).enumerate() {
         let info = || InstInfo { block, pos };
@@ -87,36 +90,6 @@ fn local_copy_prop_prememcpy(context: &mut Context, function: Function) -> Resul
                     instr_info_map.insert(inst, info());
                 }
             }
-            Instruction {
-                op: InstOp::PtrToInt(value, _),
-                ..
-            } => {
-                if let Some(local) = get_referred_symbol(context, *value) {
-                    escaping_uses.insert(local);
-                }
-            }
-            Instruction {
-                op: InstOp::AsmBlock(_, args),
-                ..
-            } => {
-                for arg in args {
-                    if let Some(arg) = arg.initializer {
-                        if let Some(local) = get_referred_symbol(context, arg) {
-                            escaping_uses.insert(local);
-                        }
-                    }
-                }
-            }
-            Instruction {
-                op: InstOp::Call(_, args),
-                ..
-            } => {
-                for arg in args {
-                    if let Some(local) = get_referred_symbol(context, *arg) {
-                        escaping_uses.insert(local);
-                    }
-                }
-            }
             _ => (),
         }
     }
@@ -191,8 +164,9 @@ fn local_copy_prop_prememcpy(context: &mut Context, function: Function) -> Resul
                             let instr_info = instr_info_map.get(load_val).unwrap();
                             instr_info.block == block && instr_info.pos > pos
                         })
-                        // We don't deal with ASM blocks and function calls.
-                        || escaping_uses.contains(&dst_local)
+                        // We don't deal with symbols that escape.
+                        || escaped_symbols.contains(&dst_local)
+                        || escaped_symbols.contains(&src_local)
                         // We don't deal part copies.
                         || dst_local.get_type(context) != src_local.get_type(context)
                         // We don't replace the destination when it's an arg.
@@ -290,7 +264,14 @@ fn local_copy_prop(
     analyses: &AnalysisResults,
     function: Function,
 ) -> Result<bool, IrError> {
-    let escaped_symbols: &EscapedSymbols = analyses.get_analysis_result(function);
+    // If the analysis result is incomplete we cannot do any safe optimizations here.
+    // The `gen_new_copy` and `process_load` functions below rely on the fact that the
+    // analyzed symbols do not escape, something we cannot guarantee in case of
+    // an incomplete collection of escaped symbols.
+    let escaped_symbols = match analyses.get_analysis_result(function) {
+        EscapedSymbols::Complete(syms) => syms,
+        EscapedSymbols::Incomplete(_) => return Ok(false),
+    };
 
     // Currently (as we scan a block) available `memcpy`s.
     let mut available_copies: FxHashSet<Value>;
@@ -310,47 +291,57 @@ fn local_copy_prop(
         src_to_copies: &mut FxIndexMap<Symbol, FxIndexSet<Value>>,
         dest_to_copies: &mut FxIndexMap<Symbol, FxIndexSet<Value>>,
     ) {
-        let rs = get_referred_symbols(context, value);
-        for sym in rs.any() {
-            if let Some(copies) = src_to_copies.get_mut(&sym) {
-                for copy in &*copies {
-                    let (_, src_ptr, copy_size) = deconstruct_memcpy(context, *copy);
-                    if memory_utils::may_alias(context, value, len, src_ptr, copy_size) {
-                        available_copies.remove(copy);
+        match get_referred_symbols(context, value) {
+            ReferredSymbols::Complete(rs) => {
+                for sym in rs {
+                    if let Some(copies) = src_to_copies.get_mut(&sym) {
+                        for copy in &*copies {
+                            let (_, src_ptr, copy_size) = deconstruct_memcpy(context, *copy);
+                            if memory_utils::may_alias(context, value, len, src_ptr, copy_size) {
+                                available_copies.remove(copy);
+                            }
+                        }
+                        copies.retain(|copy| available_copies.contains(copy));
                     }
-                }
-                copies.retain(|copy| available_copies.contains(copy));
-            }
-            if let Some(copies) = dest_to_copies.get_mut(&sym) {
-                for copy in &*copies {
-                    let (dest_ptr, copy_size) = match copy.get_instruction(context).unwrap() {
-                        Instruction {
-                            op:
-                                InstOp::MemCopyBytes {
-                                    dst_val_ptr,
-                                    src_val_ptr: _,
-                                    byte_len,
-                                },
-                            ..
-                        } => (*dst_val_ptr, *byte_len),
-                        Instruction {
-                            op:
-                                InstOp::MemCopyVal {
-                                    dst_val_ptr,
-                                    src_val_ptr: _,
-                                },
-                            ..
-                        } => (
-                            *dst_val_ptr,
-                            memory_utils::pointee_size(context, *dst_val_ptr),
-                        ),
-                        _ => panic!("Unexpected copy instruction"),
-                    };
-                    if memory_utils::may_alias(context, value, len, dest_ptr, copy_size) {
-                        available_copies.remove(copy);
+                    if let Some(copies) = dest_to_copies.get_mut(&sym) {
+                        for copy in &*copies {
+                            let (dest_ptr, copy_size) = match copy.get_instruction(context).unwrap()
+                            {
+                                Instruction {
+                                    op:
+                                        InstOp::MemCopyBytes {
+                                            dst_val_ptr,
+                                            src_val_ptr: _,
+                                            byte_len,
+                                        },
+                                    ..
+                                } => (*dst_val_ptr, *byte_len),
+                                Instruction {
+                                    op:
+                                        InstOp::MemCopyVal {
+                                            dst_val_ptr,
+                                            src_val_ptr: _,
+                                        },
+                                    ..
+                                } => (
+                                    *dst_val_ptr,
+                                    memory_utils::pointee_size(context, *dst_val_ptr),
+                                ),
+                                _ => panic!("Unexpected copy instruction"),
+                            };
+                            if memory_utils::may_alias(context, value, len, dest_ptr, copy_size) {
+                                available_copies.remove(copy);
+                            }
+                        }
+                        copies.retain(|copy| available_copies.contains(copy));
                     }
                 }
-                copies.retain(|copy| available_copies.contains(copy));
+            }
+            ReferredSymbols::Incomplete(_) => {
+                // The only safe thing we can do is to clear all information.
+                available_copies.clear();
+                src_to_copies.clear();
+                dest_to_copies.clear();
             }
         }
     }
@@ -358,7 +349,7 @@ fn local_copy_prop(
     #[allow(clippy::too_many_arguments)]
     fn gen_new_copy(
         context: &Context,
-        escaped_symbols: &EscapedSymbols,
+        escaped_symbols: &FxHashSet<Symbol>,
         copy_inst: Value,
         dst_val_ptr: Value,
         src_val_ptr: Value,
@@ -429,7 +420,7 @@ fn local_copy_prop(
 
     fn process_load(
         context: &Context,
-        escaped_symbols: &EscapedSymbols,
+        escaped_symbols: &FxHashSet<Symbol>,
         inst: Value,
         src_val_ptr: Value,
         dest_to_copies: &FxIndexMap<Symbol, FxIndexSet<Value>>,
@@ -499,6 +490,7 @@ fn local_copy_prop(
                 }
             }
         }
+
         false
     }
 
@@ -527,24 +519,35 @@ fn local_copy_prop(
                 dest_to_copies: &mut FxIndexMap<Symbol, FxIndexSet<Value>>,
             ) {
                 for arg in args {
-                    let max_size = get_referred_symbols(context, *arg)
-                        .any()
-                        .iter()
-                        .filter_map(|sym| {
-                            sym.get_type(context)
-                                .get_pointee_type(context)
-                                .map(|pt| pt.size(context).in_bytes())
-                        })
-                        .max()
-                        .unwrap_or(0);
-                    kill_defined_symbol(
-                        context,
-                        *arg,
-                        max_size,
-                        available_copies,
-                        src_to_copies,
-                        dest_to_copies,
-                    );
+                    match get_referred_symbols(context, *arg) {
+                        ReferredSymbols::Complete(rs) => {
+                            let max_size = rs
+                                .iter()
+                                .filter_map(|sym| {
+                                    sym.get_type(context)
+                                        .get_pointee_type(context)
+                                        .map(|pt| pt.size(context).in_bytes())
+                                })
+                                .max()
+                                .unwrap_or(0);
+                            kill_defined_symbol(
+                                context,
+                                *arg,
+                                max_size,
+                                available_copies,
+                                src_to_copies,
+                                dest_to_copies,
+                            );
+                        }
+                        ReferredSymbols::Incomplete(_) => {
+                            // The only safe thing we can do is to clear all information.
+                            available_copies.clear();
+                            src_to_copies.clear();
+                            dest_to_copies.clear();
+
+                            break;
+                        }
+                    }
                 }
             }
 
@@ -647,6 +650,27 @@ fn local_copy_prop(
                             &mut dest_to_copies,
                         );
                     }
+                    Instruction {
+                        op:
+                            InstOp::FuelVm(
+                                FuelVmInstruction::WideBinaryOp { result, .. }
+                                | FuelVmInstruction::WideUnaryOp { result, .. }
+                                | FuelVmInstruction::WideModularOp { result, .. }
+                                | FuelVmInstruction::StateLoadQuadWord {
+                                    load_val: result, ..
+                                },
+                            ),
+                        ..
+                    } => {
+                        kill_defined_symbol(
+                            context,
+                            *result,
+                            memory_utils::pointee_size(context, *result),
+                            &mut available_copies,
+                            &mut src_to_copies,
+                            &mut dest_to_copies,
+                        );
+                    }
                     _ => (),
                 }
             }
@@ -733,21 +757,53 @@ fn local_copy_prop(
     Ok(modified)
 }
 
+struct Candidate {
+    load_val: Value,
+    store_val: Value,
+    dst_ptr: Value,
+    src_ptr: Value,
+}
+
+enum CandidateKind {
+    /// If aggregates are clobbered b/w a load and the store, we still need to,
+    /// for correctness (because asmgen cannot handle aggregate loads and stores)
+    /// do the memcpy. So we insert a memcpy to a temporary stack location right after
+    /// the load, and memcpy it to the store pointer at the point of store.
+    ClobberedNoncopyType(Candidate),
+    NonClobbered(Candidate),
+}
+
 // Is (an alias of) src_ptr clobbered on any path from load_val to store_val?
 fn is_clobbered(
     context: &Context,
-    store_block: Block,
-    store_val: Value,
-    load_val: Value,
-    src_ptr: Value,
+    Candidate {
+        load_val,
+        store_val,
+        dst_ptr,
+        src_ptr,
+    }: &Candidate,
 ) -> bool {
+    let store_block = store_val.get_instruction(context).unwrap().parent;
+
     let mut iter = store_block
         .instruction_iter(context)
         .rev()
-        .skip_while(|i| i != &store_val);
-    assert!(iter.next().unwrap() == store_val);
+        .skip_while(|i| i != store_val);
+    assert!(iter.next().unwrap() == *store_val);
 
-    let src_symbols = get_gep_referred_symbols(context, src_ptr);
+    let ReferredSymbols::Complete(src_symbols) = get_referred_symbols(context, *src_ptr) else {
+        return true;
+    };
+
+    let ReferredSymbols::Complete(dst_symbols) = get_referred_symbols(context, *dst_ptr) else {
+        return true;
+    };
+
+    // If the source and destination may have an overlap, we'll end up generating a mcp
+    // with overlapping source/destination which is not allowed.
+    if src_symbols.intersection(&dst_symbols).next().is_some() {
+        return true;
+    }
 
     // Scan backwards till we encounter load_val, checking if
     // any store aliases with src_ptr.
@@ -757,25 +813,17 @@ fn is_clobbered(
     'next_job: while let Some((block, iter)) = worklist.pop() {
         visited.insert(block);
         for inst in iter {
-            if inst == load_val || inst == store_val {
+            if inst == *load_val || inst == *store_val {
                 // We don't need to go beyond either the source load or the candidate store.
                 continue 'next_job;
             }
-            if let Some(Instruction {
-                op:
-                    InstOp::Store {
-                        dst_val_ptr,
-                        stored_val: _,
-                    },
-                ..
-            }) = inst.get_instruction(context)
-            {
-                if get_gep_referred_symbols(context, *dst_val_ptr)
-                    .iter()
-                    .any(|sym| src_symbols.contains(sym))
-                {
+            let stored_syms = get_stored_symbols(context, inst);
+            if let ReferredSymbols::Complete(syms) = stored_syms {
+                if syms.iter().any(|sym| src_symbols.contains(sym)) {
                     return true;
                 }
+            } else {
+                return true;
             }
         }
         for pred in block.pred_iter(context) {
@@ -791,12 +839,20 @@ fn is_clobbered(
     false
 }
 
+// This is a copy of sway_core::asm_generation::fuel::fuel_asm_builder::FuelAsmBuilder::is_copy_type.
+fn is_copy_type(ty: &Type, context: &Context) -> bool {
+    ty.is_unit(context)
+        || ty.is_never(context)
+        || ty.is_bool(context)
+        || ty.get_uint_width(context).map(|x| x < 256).unwrap_or(false)
+}
+
 fn load_store_to_memcopy(context: &mut Context, function: Function) -> Result<bool, IrError> {
     // Find any `store`s of `load`s.  These can be replaced with `mem_copy` and are especially
     // important for non-copy types on architectures which don't support loading them.
     let candidates = function
         .instruction_iter(context)
-        .filter_map(|(block, store_instr_val)| {
+        .filter_map(|(_, store_instr_val)| {
             store_instr_val
                 .get_instruction(context)
                 .and_then(|instr| {
@@ -824,24 +880,26 @@ fn load_store_to_memcopy(context: &mut Context, function: Function) -> Result<bo
                         ..
                     } = src_instr
                     {
-                        Some((
-                            block,
-                            src_instr_val,
-                            store_instr_val,
-                            *dst_val_ptr,
-                            *src_val_ptr,
-                        ))
+                        Some(Candidate {
+                            load_val: src_instr_val,
+                            store_val: store_instr_val,
+                            dst_ptr: *dst_val_ptr,
+                            src_ptr: *src_val_ptr,
+                        })
+                    } else {
+                        None
+                    }
+                })
+                .and_then(|candidate @ Candidate { dst_ptr, .. }| {
+                    // Check that there's no path from load_val to store_val that might overwrite src_ptr.
+                    if !is_clobbered(context, &candidate) {
+                        Some(CandidateKind::NonClobbered(candidate))
+                    } else if !is_copy_type(&dst_ptr.match_ptr_type(context).unwrap(), context) {
+                        Some(CandidateKind::ClobberedNoncopyType(candidate))
                     } else {
                         None
                     }
                 })
-                .and_then(
-                    |candidate @ (block, load_val, store_val, _dst_ptr, src_ptr)| {
-                        // Ensure that there's no path from load_val to store_val that might overwrite src_ptr.
-                        (!is_clobbered(context, block, store_val, load_val, src_ptr))
-                            .then_some(candidate)
-                    },
-                )
         })
         .collect::<Vec<_>>();
 
@@ -849,16 +907,68 @@ fn load_store_to_memcopy(context: &mut Context, function: Function) -> Result<bo
         return Ok(false);
     }
 
-    for (block, _src_instr_val, store_val, dst_val_ptr, src_val_ptr) in candidates {
-        let mem_copy_val = Value::new_instruction(
-            context,
-            block,
-            InstOp::MemCopyVal {
-                dst_val_ptr,
-                src_val_ptr,
-            },
-        );
-        block.replace_instruction(context, store_val, mem_copy_val, true)?;
+    for candidate in candidates {
+        match candidate {
+            CandidateKind::ClobberedNoncopyType(Candidate {
+                load_val,
+                store_val,
+                dst_ptr,
+                src_ptr,
+            }) => {
+                let load_block = load_val.get_instruction(context).unwrap().parent;
+                let temp = function.new_unique_local_var(
+                    context,
+                    "__aggr_memcpy_0".into(),
+                    src_ptr.match_ptr_type(context).unwrap(),
+                    None,
+                    true,
+                );
+                let temp_local =
+                    Value::new_instruction(context, load_block, InstOp::GetLocal(temp));
+                let to_temp = Value::new_instruction(
+                    context,
+                    load_block,
+                    InstOp::MemCopyVal {
+                        dst_val_ptr: temp_local,
+                        src_val_ptr: src_ptr,
+                    },
+                );
+                let mut inserter = InstructionInserter::new(
+                    context,
+                    load_block,
+                    crate::InsertionPosition::After(load_val),
+                );
+                inserter.insert_slice(&[temp_local, to_temp]);
+
+                let store_block = store_val.get_instruction(context).unwrap().parent;
+                let mem_copy_val = Value::new_instruction(
+                    context,
+                    store_block,
+                    InstOp::MemCopyVal {
+                        dst_val_ptr: dst_ptr,
+                        src_val_ptr: temp_local,
+                    },
+                );
+                store_block.replace_instruction(context, store_val, mem_copy_val, true)?;
+            }
+            CandidateKind::NonClobbered(Candidate {
+                dst_ptr: dst_val_ptr,
+                src_ptr: src_val_ptr,
+                store_val,
+                ..
+            }) => {
+                let store_block = store_val.get_instruction(context).unwrap().parent;
+                let mem_copy_val = Value::new_instruction(
+                    context,
+                    store_block,
+                    InstOp::MemCopyVal {
+                        dst_val_ptr,
+                        src_val_ptr,
+                    },
+                );
+                store_block.replace_instruction(context, store_val, mem_copy_val, true)?;
+            }
+        }
     }
 
     Ok(true)
diff --git a/sway-ir/src/optimize/sroa.rs b/sway-ir/src/optimize/sroa.rs
index da933e9c793..70c8160362c 100644
--- a/sway-ir/src/optimize/sroa.rs
+++ b/sway-ir/src/optimize/sroa.rs
@@ -5,7 +5,8 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
     combine_indices, compute_escaped_symbols, get_gep_referred_symbols, get_loaded_ptr_values,
     get_stored_ptr_values, pointee_size, AnalysisResults, Constant, ConstantValue, Context,
-    Function, InstOp, IrError, LocalVar, Pass, PassMutability, ScopedPass, Symbol, Type, Value,
+    EscapedSymbols, Function, InstOp, IrError, LocalVar, Pass, PassMutability, ScopedPass, Symbol,
+    Type, Value,
 };
 
 pub const SROA_NAME: &str = "sroa";
@@ -403,6 +404,7 @@ fn is_processable_aggregate(context: &Context, ty: Type) -> bool {
                 fields.iter().all(|ty| check_sub_types(context, *ty))
             }
             crate::TypeContent::Slice => false,
+            crate::TypeContent::TypedSlice(..) => false,
             crate::TypeContent::Pointer(_) => true,
             crate::TypeContent::StringSlice => false,
             crate::TypeContent::StringArray(_) => false,
@@ -442,7 +444,11 @@ fn profitability(context: &Context, function: Function, candidates: &mut FxHashS
 /// 3. Never accessed via non-const indexing.
 /// 4. Not aliased via a pointer that may point to more than one symbol.
 fn candidate_symbols(context: &Context, function: Function) -> FxHashSet<Symbol> {
-    let escaped_symbols = compute_escaped_symbols(context, &function);
+    let escaped_symbols = match compute_escaped_symbols(context, &function) {
+        EscapedSymbols::Complete(syms) => syms,
+        EscapedSymbols::Incomplete(_) => return FxHashSet::<_>::default(),
+    };
+
     let mut candidates: FxHashSet<Symbol> = function
         .locals_iter(context)
         .filter_map(|(_, l)| {
diff --git a/sway-ir/src/parser.rs b/sway-ir/src/parser.rs
index 422b9e9ea1a..bb77348cf81 100644
--- a/sway-ir/src/parser.rs
+++ b/sway-ir/src/parser.rs
@@ -85,13 +85,18 @@ mod ir_builder {
                 }
 
             rule fn_decl() -> IrAstFnDecl
-                = is_public:is_public() _ is_entry:is_entry() _  is_fallback:is_fallback() _ "fn" _
+                = is_public:is_public() _ is_entry:is_entry() _  is_original_entry:is_original_entry() _ is_fallback:is_fallback() _ "fn" _
                         name:id() _ selector:selector_id()? _ "(" _
                         args:(block_arg() ** comma()) ")" _ "->" _ ret_type:ast_ty()
                             metadata:comma_metadata_idx()? "{" _
                         locals:fn_local()*
                         blocks:block_decl()*
                     "}" _ {
+                    // TODO: Remove once old decoding is removed.
+                    //       In the case of old decoding, every entry is at the same time an original entry, but in the IR
+                    //       we mark them only as `entry`s so there is a bit of information lost at the roundtrip.
+                    //       Remove this hack to recognize the new encoding once it becomes the only encoding.
+                    let is_original_entry = is_original_entry || (is_entry && !name.starts_with("__entry"));
                     IrAstFnDecl {
                         name,
                         args,
@@ -102,6 +107,7 @@ mod ir_builder {
                         blocks,
                         selector,
                         is_entry,
+                        is_original_entry,
                         is_fallback,
                     }
                 }
@@ -114,6 +120,10 @@ mod ir_builder {
                 = "entry" _ { true }
                 / "" _ { false }
 
+            rule is_original_entry() -> bool
+                = "entry_orig" _ { true }
+                / "" _ { false }
+
             rule is_fallback() -> bool
                 = "fallback" _ { true }
                 / "" _ { false }
@@ -225,13 +235,13 @@ mod ir_builder {
                 / op_store()
 
             rule op_asm() -> IrAstOperation
-                = "asm" _ "(" _ args:(asm_arg() ** comma()) ")" _ ret:asm_ret()? meta_idx:comma_metadata_idx()? "{" _
+                = "asm" _ "(" _ args:(asm_arg() ** comma()) ")" _ ret:asm_ret() meta_idx:comma_metadata_idx()? "{" _
                     ops:asm_op()*
                 "}" _ {
                     IrAstOperation::Asm(
                         args,
-                        ret.clone().map(|(ty, _)| ty).unwrap_or(IrAstTy::Unit),
-                        ret.map(|(_, nm)| nm),
+                        ret.0,
+                        ret.1,
                         ops,
                         meta_idx
                     )
@@ -445,8 +455,8 @@ mod ir_builder {
                     IrAstAsmArgInit::Var(var)
                 }
 
-            rule asm_ret() -> (IrAstTy, Ident)
-                = "->" _ ty:ast_ty() ret:id_id() {
+            rule asm_ret() -> (IrAstTy, Option<Ident>)
+                = "->" _ ty:ast_ty() ret:id_id()? {
                     (ty, ret)
                 }
 
@@ -699,6 +709,7 @@ mod ir_builder {
         blocks: Vec<IrAstBlock>,
         selector: Option<[u8; 4]>,
         is_entry: bool,
+        is_original_entry: bool,
         is_fallback: bool,
     }
 
@@ -942,6 +953,7 @@ mod ir_builder {
     // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
     use std::{
+        cell::Cell,
         collections::{BTreeMap, HashMap},
         iter::FromIterator,
     };
@@ -1008,6 +1020,7 @@ mod ir_builder {
                 fn_decl.selector,
                 fn_decl.is_public,
                 fn_decl.is_entry,
+                fn_decl.is_original_entry,
                 fn_decl.is_fallback,
                 convert_md_idx(&fn_decl.metadata),
             );
@@ -1453,7 +1466,7 @@ mod ir_builder {
                     .configs
                     .get_mut(&configurable_name)
                 {
-                    *decode_fn = f;
+                    decode_fn.replace(f);
                 }
             }
 
@@ -1509,7 +1522,7 @@ mod ir_builder {
                     ptr_ty: Type::new_ptr(context, ty),
                     encoded_bytes: config.encoded_bytes,
                     // this will point to the correct function after all functions are compiled
-                    decode_fn: Function(KeyData::default().into()),
+                    decode_fn: Cell::new(Function(KeyData::default().into())),
                     opt_metadata,
                 };
 
diff --git a/sway-ir/src/pass_manager.rs b/sway-ir/src/pass_manager.rs
index 3aafda779ad..b1c069a39dd 100644
--- a/sway-ir/src/pass_manager.rs
+++ b/sway-ir/src/pass_manager.rs
@@ -1,14 +1,15 @@
 use crate::{
-    create_arg_demotion_pass, create_const_demotion_pass, create_const_folding_pass,
-    create_dce_pass, create_dom_fronts_pass, create_dominators_pass, create_escaped_symbols_pass,
-    create_fn_dce_pass, create_fn_dedup_debug_profile_pass, create_fn_dedup_release_profile_pass,
+    create_arg_demotion_pass, create_ccp_pass, create_const_demotion_pass,
+    create_const_folding_pass, create_cse_pass, create_dce_pass, create_dom_fronts_pass,
+    create_dominators_pass, create_escaped_symbols_pass, create_fn_dce_pass,
+    create_fn_dedup_debug_profile_pass, create_fn_dedup_release_profile_pass,
     create_fn_inline_pass, create_mem2reg_pass, create_memcpyopt_pass, create_misc_demotion_pass,
     create_module_printer_pass, create_module_verifier_pass, create_postorder_pass,
     create_ret_demotion_pass, create_simplify_cfg_pass, create_sroa_pass, Context, Function,
-    IrError, Module, ARG_DEMOTION_NAME, CONST_DEMOTION_NAME, CONST_FOLDING_NAME, DCE_NAME,
-    FN_DCE_NAME, FN_DEDUP_DEBUG_PROFILE_NAME, FN_DEDUP_RELEASE_PROFILE_NAME, FN_INLINE_NAME,
-    MEM2REG_NAME, MEMCPYOPT_NAME, MISC_DEMOTION_NAME, RET_DEMOTION_NAME, SIMPLIFY_CFG_NAME,
-    SROA_NAME,
+    IrError, Module, ARG_DEMOTION_NAME, CCP_NAME, CONST_DEMOTION_NAME, CONST_FOLDING_NAME,
+    CSE_NAME, DCE_NAME, FN_DCE_NAME, FN_DEDUP_DEBUG_PROFILE_NAME, FN_DEDUP_RELEASE_PROFILE_NAME,
+    FN_INLINE_NAME, MEM2REG_NAME, MEMCPYOPT_NAME, MISC_DEMOTION_NAME, RET_DEMOTION_NAME,
+    SIMPLIFY_CFG_NAME, SROA_NAME,
 };
 use downcast_rs::{impl_downcast, Downcast};
 use rustc_hash::FxHashMap;
@@ -396,9 +397,11 @@ pub fn register_known_passes(pm: &mut PassManager) {
     pm.register(create_sroa_pass());
     pm.register(create_fn_inline_pass());
     pm.register(create_const_folding_pass());
+    pm.register(create_ccp_pass());
     pm.register(create_simplify_cfg_pass());
     pm.register(create_fn_dce_pass());
     pm.register(create_dce_pass());
+    pm.register(create_cse_pass());
     pm.register(create_arg_demotion_pass());
     pm.register(create_const_demotion_pass());
     pm.register(create_ret_demotion_pass());
@@ -407,7 +410,7 @@ pub fn register_known_passes(pm: &mut PassManager) {
 }
 
 pub fn create_o1_pass_group() -> PassGroup {
-    // Create a configuration to specify which passes we want to run now.
+    // Create a create_ccp_passo specify which passes we want to run now.
     let mut o1 = PassGroup::default();
     // Configure to run our passes.
     o1.append_pass(MEM2REG_NAME);
@@ -416,12 +419,15 @@ pub fn create_o1_pass_group() -> PassGroup {
     o1.append_pass(SIMPLIFY_CFG_NAME);
     o1.append_pass(FN_DCE_NAME);
     o1.append_pass(FN_INLINE_NAME);
+    o1.append_pass(CCP_NAME);
     o1.append_pass(CONST_FOLDING_NAME);
     o1.append_pass(SIMPLIFY_CFG_NAME);
+    o1.append_pass(CSE_NAME);
     o1.append_pass(CONST_FOLDING_NAME);
     o1.append_pass(SIMPLIFY_CFG_NAME);
     o1.append_pass(FN_DCE_NAME);
     o1.append_pass(DCE_NAME);
+    o1.append_pass(FN_DEDUP_RELEASE_PROFILE_NAME);
 
     o1
 }
diff --git a/sway-ir/src/printer.rs b/sway-ir/src/printer.rs
index edd1986b895..b589c329c3b 100644
--- a/sway-ir/src/printer.rs
+++ b/sway-ir/src/printer.rs
@@ -23,7 +23,7 @@ use crate::{
 };
 
 #[derive(Debug)]
-enum Doc {
+pub(crate) enum Doc {
     Empty,
     Space,
     Comma,
@@ -42,7 +42,7 @@ enum Doc {
 }
 
 impl Doc {
-    fn text<S: Into<String>>(s: S) -> Self {
+    pub(crate) fn text<S: Into<String>>(s: S) -> Self {
         Doc::Text(s.into())
     }
 
@@ -50,7 +50,7 @@ impl Doc {
         Doc::Line(Box::new(doc))
     }
 
-    fn text_line<S: Into<String>>(s: S) -> Self {
+    pub(crate) fn text_line<S: Into<String>>(s: S) -> Self {
         Doc::Line(Box::new(Doc::Text(s.into())))
     }
 
@@ -66,7 +66,7 @@ impl Doc {
         Doc::Parens(Box::new(Doc::list_sep(docs, Doc::Comma)))
     }
 
-    fn append(self, doc: Doc) -> Doc {
+    pub(crate) fn append(self, doc: Doc) -> Doc {
         match (&self, &doc) {
             (Doc::Empty, _) => doc,
             (_, Doc::Empty) => self,
@@ -81,7 +81,7 @@ impl Doc {
         }
     }
 
-    fn build(self) -> String {
+    pub(crate) fn build(self) -> String {
         build_doc(self, 0)
     }
 }
@@ -90,17 +90,32 @@ impl Doc {
 ///
 /// The output from this function must always be suitable for [crate::parser::parse].
 pub fn to_string(context: &Context) -> String {
+    context_print(context, &|_, doc| doc)
+}
+
+pub(crate) fn context_print(context: &Context, map_doc: &impl Fn(&Value, Doc) -> Doc) -> String {
     let mut md_namer = MetadataNamer::default();
     context
         .modules
         .iter()
         .fold(Doc::Empty, |doc, (_, module)| {
-            doc.append(module_to_doc(context, &mut md_namer, module))
+            doc.append(module_to_doc(context, &mut md_namer, module, map_doc))
         })
         .append(md_namer.to_doc(context))
         .build()
 }
 
+pub(crate) fn block_print(
+    context: &Context,
+    function: Function,
+    block: Block,
+    map_doc: &impl Fn(&Value, Doc) -> Doc,
+) -> String {
+    let mut md_namer = MetadataNamer::default();
+    let mut namer = Namer::new(function);
+    block_to_doc(context, &mut md_namer, &mut namer, &block, map_doc).build()
+}
+
 pub struct ModulePrinterResult;
 impl AnalysisResultT for ModulePrinterResult {}
 
@@ -116,7 +131,8 @@ pub fn module_printer_pass(
         module_to_doc(
             context,
             &mut md_namer,
-            context.modules.get(module.0).unwrap()
+            context.modules.get(module.0).unwrap(),
+            &|_, doc| doc
         )
         .append(md_namer.to_doc(context))
         .build()
@@ -132,7 +148,8 @@ pub fn module_print(context: &Context, _analyses: &AnalysisResults, module: Modu
         module_to_doc(
             context,
             &mut md_namer,
-            context.modules.get(module.0).unwrap()
+            context.modules.get(module.0).unwrap(),
+            &|_, doc| doc
         )
         .append(md_namer.to_doc(context))
         .build()
@@ -148,7 +165,8 @@ pub fn function_print(context: &Context, function: Function) {
             context,
             &mut md_namer,
             &mut Namer::new(function),
-            context.functions.get(function.0).unwrap()
+            context.functions.get(function.0).unwrap(),
+            &|_, doc| doc
         )
         .append(md_namer.to_doc(context))
         .build()
@@ -170,6 +188,7 @@ fn module_to_doc<'a>(
     context: &'a Context,
     md_namer: &mut MetadataNamer,
     module: &'a ModuleContent,
+    map_doc: &impl Fn(&Value, Doc) -> Doc,
 ) -> Doc {
     Doc::line(Doc::Text(format!(
         "{} {{",
@@ -207,6 +226,7 @@ fn module_to_doc<'a>(
                         md_namer,
                         &mut Namer::new(*function),
                         &context.functions[function.0],
+                        map_doc,
                     )
                 })
                 .collect(),
@@ -254,7 +274,7 @@ fn config_to_doc(
                     "{} = config {}, {}, 0x{}",
                     name,
                     ty,
-                    decode_fn.get_name(context),
+                    decode_fn.get().get_name(context),
                     bytes,
                 ))
                 .append(md_namer.md_idx_to_doc(context, opt_metadata)),
@@ -268,9 +288,29 @@ fn function_to_doc<'a>(
     md_namer: &mut MetadataNamer,
     namer: &mut Namer,
     function: &'a FunctionContent,
+    map_doc: &impl Fn(&Value, Doc) -> Doc,
 ) -> Doc {
     let public = if function.is_public { "pub " } else { "" };
     let entry = if function.is_entry { "entry " } else { "" };
+    // TODO: Remove outer `if` once old encoding is fully removed.
+    //       This is an intentional "complication" so that we see
+    //       explicit using of `new_encoding` here.
+    //       For the time being, for the old encoding, we don't want
+    //       to show both `entry` and `entry_orig` although both
+    //       values will be true.
+    // TODO: When removing old encoding, remove also the TODO in the
+    //       `rule fn_decl()` definition of the IR parser.
+    let original_entry = if context.experimental.new_encoding {
+        if function.is_original_entry {
+            "entry_orig "
+        } else {
+            ""
+        }
+    } else if !function.is_entry && function.is_original_entry {
+        "entry_orig "
+    } else {
+        ""
+    };
     let fallback = if function.is_fallback {
         "fallback "
     } else {
@@ -278,8 +318,8 @@ fn function_to_doc<'a>(
     };
     Doc::line(
         Doc::text(format!(
-            "{}{}{}fn {}",
-            public, entry, fallback, function.name
+            "{}{}{}{}fn {}",
+            public, entry, original_entry, fallback, function.name
         ))
         .append(
             function
@@ -354,7 +394,7 @@ fn function_to_doc<'a>(
                     function
                         .blocks
                         .iter()
-                        .map(|block| block_to_doc(context, md_namer, namer, block))
+                        .map(|block| block_to_doc(context, md_namer, namer, block, map_doc))
                         .collect(),
                     Doc::line(Doc::Empty),
                 ),
@@ -370,6 +410,7 @@ fn block_to_doc(
     md_namer: &mut MetadataNamer,
     namer: &mut Namer,
     block: &Block,
+    map_doc: &impl Fn(&Value, Doc) -> Doc,
 ) -> Doc {
     let block_content = &context.blocks[block.0];
     Doc::line(
@@ -391,7 +432,10 @@ fn block_to_doc(
     .append(Doc::List(
         block
             .instruction_iter(context)
-            .map(|ins| instruction_to_doc(context, md_namer, namer, block, &ins))
+            .map(|current_value| {
+                let doc = instruction_to_doc(context, md_namer, namer, block, &current_value);
+                (map_doc)(&current_value, doc)
+            })
             .collect(),
     ))
 }
@@ -1050,13 +1094,14 @@ fn asm_block_to_doc(
                         .collect(),
                 ))
                 .append(
-                    return_name
-                        .as_ref()
-                        .map(|rn| {
-                            Doc::text(format!(" -> {} {rn}", return_type.as_string(context)))
-                                .append(md_namer.md_idx_to_doc(context, metadata))
-                        })
-                        .unwrap_or(Doc::Empty),
+                    Doc::text(format!(
+                        " -> {}{}",
+                        return_type.as_string(context),
+                        return_name
+                            .as_ref()
+                            .map_or("".to_string(), |rn| format!(" {rn}"))
+                    ))
+                    .append(md_namer.md_idx_to_doc(context, metadata)),
                 )
                 .append(Doc::text(" {")),
         ))
@@ -1144,6 +1189,15 @@ impl Constant {
                     .collect::<Vec<String>>()
                     .join(", ")
             ),
+            ConstantValue::Slice(elems) => format!(
+                "__slice[{}] [{}]",
+                self.ty.as_string(context),
+                elems
+                    .iter()
+                    .map(|elem| elem.as_lit_string(context))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
             ConstantValue::Struct(fields) => format!(
                 "{} {{ {} }}",
                 self.ty.as_string(context),
diff --git a/sway-ir/src/value.rs b/sway-ir/src/value.rs
index b89aa242303..42324aca351 100644
--- a/sway-ir/src/value.rs
+++ b/sway-ir/src/value.rs
@@ -12,7 +12,7 @@ use crate::{
     block::BlockArgument,
     constant::Constant,
     context::Context,
-    instruction::{FuelVmInstruction, InstOp},
+    instruction::InstOp,
     irtype::Type,
     metadata::{combine, MetadataIndex},
     pretty::DebugWithContext,
@@ -102,13 +102,7 @@ impl Value {
     /// and is either a branch or return.
     pub fn is_terminator(&self, context: &Context) -> bool {
         match &context.values[self.0].value {
-            ValueDatum::Instruction(Instruction { op, .. }) => matches!(
-                op,
-                InstOp::Branch(_)
-                    | InstOp::ConditionalBranch { .. }
-                    | InstOp::Ret(_, _)
-                    | InstOp::FuelVm(FuelVmInstruction::Revert(_) | FuelVmInstruction::JmpMem)
-            ),
+            ValueDatum::Instruction(Instruction { op, .. }) => op.is_terminator(),
             ValueDatum::Argument(..) | ValueDatum::Constant(..) => false,
         }
     }
@@ -176,6 +170,15 @@ impl Value {
         }
     }
 
+    /// Get a mutable reference to this value as an argument, iff it is one.
+    pub fn get_argument_mut<'a>(&self, context: &'a mut Context) -> Option<&'a mut BlockArgument> {
+        if let ValueDatum::Argument(arg) = &mut context.values[self.0].value {
+            Some(arg)
+        } else {
+            None
+        }
+    }
+
     /// Get the type for this value, if found.
     ///
     /// Arguments and constants always have a type, but only some instructions do.
diff --git a/sway-ir/src/verify.rs b/sway-ir/src/verify.rs
index af987ab4a25..f5bbb39cea9 100644
--- a/sway-ir/src/verify.rs
+++ b/sway-ir/src/verify.rs
@@ -13,9 +13,10 @@ use crate::{
     irtype::Type,
     local_var::LocalVar,
     metadata::{MetadataIndex, Metadatum},
+    printer,
     value::{Value, ValueDatum},
     AnalysisResult, AnalysisResultT, AnalysisResults, BinaryOpKind, Block, BlockArgument,
-    BranchToWithArgs, Module, Pass, PassMutability, ScopedPass, TypeOption, UnaryOpKind,
+    BranchToWithArgs, Doc, Module, Pass, PassMutability, ScopedPass, TypeOption, UnaryOpKind,
 };
 
 pub struct ModuleVerifierResult;
@@ -67,7 +68,19 @@ impl<'eng> Context<'eng> {
                 format!("Module_Index_{:?}", function.get_module(self).0),
             ));
         }
+
         let entry_block = function.get_entry_block(self);
+
+        if entry_block.num_predecessors(self) != 0 {
+            return Err(IrError::VerifyEntryBlockHasPredecessors(
+                function.get_name(self).to_string(),
+                entry_block
+                    .pred_iter(self)
+                    .map(|block| block.get_label(self))
+                    .collect(),
+            ));
+        }
+
         // Ensure that the entry block arguments are same as function arguments.
         if function.num_args(self) != entry_block.num_args(self) {
             return Err(IrError::VerifyBlockArgMalformed);
@@ -119,10 +132,29 @@ impl<'eng> Context<'eng> {
         }
         .verify_instructions();
 
-        if r.is_err() {
-            println!("{}", self);
-            println!("{}", cur_function.get_name(self));
-            println!("{}", cur_block.get_label(self));
+        // Help to understand the verification failure
+        // If the error knows the problematic value, prints everything with the error highlighted,
+        // if not, print only the block to help pinpoint the issue
+        if let Err(error) = &r {
+            println!(
+                "Verification failed at {}::{}",
+                cur_function.get_name(self),
+                cur_block.get_label(self)
+            );
+
+            let block = if let Some(problematic_value) = error.get_problematic_value() {
+                printer::context_print(self, &|current_value: &Value, doc: Doc| {
+                    if *current_value == *problematic_value {
+                        doc.append(Doc::text_line(format!("\x1b[0;31m^ {}\x1b[0m", error)))
+                    } else {
+                        doc
+                    }
+                })
+            } else {
+                printer::block_print(self, cur_function, cur_block, &|_, doc| doc)
+            };
+
+            println!("{}", block);
         }
 
         r?;
@@ -195,131 +227,131 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
     fn verify_instructions(&self) -> Result<(), IrError> {
         for ins in self.cur_block.instruction_iter(self.context) {
             let value_content = &self.context.values[ins.0];
-            if let ValueDatum::Instruction(instruction) = &value_content.value {
-                if instruction.parent != self.cur_block {
-                    return Err(IrError::InconsistentParent(
-                        format!("Instr_{:?}", ins.0),
-                        self.cur_block.get_label(self.context),
-                        instruction.parent.get_label(self.context),
-                    ));
+            let ValueDatum::Instruction(instruction) = &value_content.value else {
+                unreachable!("The value must be an instruction, because it is retrieved via block instruction iterator.")
+            };
+
+            if instruction.parent != self.cur_block {
+                return Err(IrError::InconsistentParent(
+                    format!("Instr_{:?}", ins.0),
+                    self.cur_block.get_label(self.context),
+                    instruction.parent.get_label(self.context),
+                ));
+            }
+
+            match &instruction.op {
+                InstOp::AsmBlock(..) => (),
+                InstOp::BitCast(value, ty) => self.verify_bitcast(value, ty)?,
+                InstOp::UnaryOp { op, arg } => self.verify_unary_op(op, arg)?,
+                InstOp::BinaryOp { op, arg1, arg2 } => self.verify_binary_op(op, arg1, arg2)?,
+                InstOp::Branch(block) => self.verify_br(block)?,
+                InstOp::Call(func, args) => self.verify_call(func, args)?,
+                InstOp::CastPtr(val, ty) => self.verify_cast_ptr(val, ty)?,
+                InstOp::Cmp(pred, lhs_value, rhs_value) => {
+                    self.verify_cmp(pred, lhs_value, rhs_value)?
                 }
-                match &instruction.op {
-                    InstOp::AsmBlock(..) => (),
-                    InstOp::BitCast(value, ty) => self.verify_bitcast(value, ty)?,
-                    InstOp::UnaryOp { op, arg } => self.verify_unary_op(op, arg)?,
-                    InstOp::BinaryOp { op, arg1, arg2 } => self.verify_binary_op(op, arg1, arg2)?,
-                    InstOp::Branch(block) => self.verify_br(block)?,
-                    InstOp::Call(func, args) => self.verify_call(func, args)?,
-                    InstOp::CastPtr(val, ty) => self.verify_cast_ptr(val, ty)?,
-                    InstOp::Cmp(pred, lhs_value, rhs_value) => {
-                        self.verify_cmp(pred, lhs_value, rhs_value)?
+                InstOp::ConditionalBranch {
+                    cond_value,
+                    true_block,
+                    false_block,
+                } => self.verify_cbr(cond_value, true_block, false_block)?,
+                InstOp::ContractCall {
+                    params,
+                    coins,
+                    asset_id,
+                    gas,
+                    ..
+                } => self.verify_contract_call(params, coins, asset_id, gas)?,
+                // XXX move the fuelvm verification into a module
+                InstOp::FuelVm(fuel_vm_instr) => match fuel_vm_instr {
+                    FuelVmInstruction::Gtf { index, tx_field_id } => {
+                        self.verify_gtf(index, tx_field_id)?
                     }
-                    InstOp::ConditionalBranch {
-                        cond_value,
-                        true_block,
-                        false_block,
-                    } => self.verify_cbr(cond_value, true_block, false_block)?,
-                    InstOp::ContractCall {
-                        params,
+                    FuelVmInstruction::Log {
+                        log_val,
+                        log_ty,
+                        log_id,
+                    } => self.verify_log(log_val, log_ty, log_id)?,
+                    FuelVmInstruction::ReadRegister(_) => (),
+                    FuelVmInstruction::JmpMem => (),
+                    FuelVmInstruction::Revert(val) => self.verify_revert(val)?,
+                    FuelVmInstruction::Smo {
+                        recipient,
+                        message,
+                        message_size,
                         coins,
-                        asset_id,
-                        gas,
-                        ..
-                    } => self.verify_contract_call(params, coins, asset_id, gas)?,
-                    // XXX move the fuelvm verification into a module
-                    InstOp::FuelVm(fuel_vm_instr) => match fuel_vm_instr {
-                        FuelVmInstruction::Gtf { index, tx_field_id } => {
-                            self.verify_gtf(index, tx_field_id)?
-                        }
-                        FuelVmInstruction::Log {
-                            log_val,
-                            log_ty,
-                            log_id,
-                        } => self.verify_log(log_val, log_ty, log_id)?,
-                        FuelVmInstruction::ReadRegister(_) => (),
-                        FuelVmInstruction::JmpMem => (),
-                        FuelVmInstruction::Revert(val) => self.verify_revert(val)?,
-                        FuelVmInstruction::Smo {
-                            recipient,
-                            message,
-                            message_size,
-                            coins,
-                        } => self.verify_smo(recipient, message, message_size, coins)?,
-                        FuelVmInstruction::StateClear {
-                            key,
-                            number_of_slots,
-                        } => self.verify_state_clear(key, number_of_slots)?,
-                        FuelVmInstruction::StateLoadWord(key) => {
-                            self.verify_state_load_word(key)?
-                        }
-                        FuelVmInstruction::StateLoadQuadWord {
-                            load_val: dst_val,
-                            key,
-                            number_of_slots,
-                        }
-                        | FuelVmInstruction::StateStoreQuadWord {
-                            stored_val: dst_val,
-                            key,
-                            number_of_slots,
-                        } => self.verify_state_access_quad(dst_val, key, number_of_slots)?,
-                        FuelVmInstruction::StateStoreWord {
-                            stored_val: dst_val,
-                            key,
-                        } => self.verify_state_store_word(dst_val, key)?,
-                        FuelVmInstruction::WideUnaryOp { op, result, arg } => {
-                            self.verify_wide_unary_op(op, result, arg)?
-                        }
-                        FuelVmInstruction::WideBinaryOp {
-                            op,
-                            result,
-                            arg1,
-                            arg2,
-                        } => self.verify_wide_binary_op(op, result, arg1, arg2)?,
-                        FuelVmInstruction::WideModularOp {
-                            op,
-                            result,
-                            arg1,
-                            arg2,
-                            arg3,
-                        } => self.verify_wide_modular_op(op, result, arg1, arg2, arg3)?,
-                        FuelVmInstruction::WideCmpOp { op, arg1, arg2 } => {
-                            self.verify_wide_cmp(op, arg1, arg2)?
-                        }
-                        FuelVmInstruction::Retd { .. } => (),
-                    },
-                    InstOp::GetElemPtr {
-                        base,
-                        elem_ptr_ty,
-                        indices,
-                    } => self.verify_get_elem_ptr(base, elem_ptr_ty, indices)?,
-                    InstOp::GetLocal(local_var) => self.verify_get_local(local_var)?,
-                    InstOp::GetConfig(_, name) => self.verify_get_config(self.cur_module, name)?,
-                    InstOp::IntToPtr(value, ty) => self.verify_int_to_ptr(value, ty)?,
-                    InstOp::Load(ptr) => self.verify_load(ptr)?,
-                    InstOp::MemCopyBytes {
-                        dst_val_ptr,
-                        src_val_ptr,
-                        byte_len,
-                    } => self.verify_mem_copy_bytes(dst_val_ptr, src_val_ptr, byte_len)?,
-                    InstOp::MemCopyVal {
-                        dst_val_ptr,
-                        src_val_ptr,
-                    } => self.verify_mem_copy_val(dst_val_ptr, src_val_ptr)?,
-                    InstOp::Nop => (),
-                    InstOp::PtrToInt(val, ty) => self.verify_ptr_to_int(val, ty)?,
-                    InstOp::Ret(val, ty) => self.verify_ret(val, ty)?,
-                    InstOp::Store {
-                        dst_val_ptr,
-                        stored_val,
-                    } => self.verify_store(dst_val_ptr, stored_val)?,
-                };
-
-                // Verify the instruction metadata too.
-                self.context.verify_metadata(value_content.metadata)?;
-            } else {
-                unreachable!("Verify instruction is not an instruction.");
-            }
+                    } => self.verify_smo(recipient, message, message_size, coins)?,
+                    FuelVmInstruction::StateClear {
+                        key,
+                        number_of_slots,
+                    } => self.verify_state_clear(key, number_of_slots)?,
+                    FuelVmInstruction::StateLoadWord(key) => self.verify_state_load_word(key)?,
+                    FuelVmInstruction::StateLoadQuadWord {
+                        load_val: dst_val,
+                        key,
+                        number_of_slots,
+                    }
+                    | FuelVmInstruction::StateStoreQuadWord {
+                        stored_val: dst_val,
+                        key,
+                        number_of_slots,
+                    } => self.verify_state_access_quad(dst_val, key, number_of_slots)?,
+                    FuelVmInstruction::StateStoreWord {
+                        stored_val: dst_val,
+                        key,
+                    } => self.verify_state_store_word(dst_val, key)?,
+                    FuelVmInstruction::WideUnaryOp { op, result, arg } => {
+                        self.verify_wide_unary_op(op, result, arg)?
+                    }
+                    FuelVmInstruction::WideBinaryOp {
+                        op,
+                        result,
+                        arg1,
+                        arg2,
+                    } => self.verify_wide_binary_op(op, result, arg1, arg2)?,
+                    FuelVmInstruction::WideModularOp {
+                        op,
+                        result,
+                        arg1,
+                        arg2,
+                        arg3,
+                    } => self.verify_wide_modular_op(op, result, arg1, arg2, arg3)?,
+                    FuelVmInstruction::WideCmpOp { op, arg1, arg2 } => {
+                        self.verify_wide_cmp(op, arg1, arg2)?
+                    }
+                    FuelVmInstruction::Retd { .. } => (),
+                },
+                InstOp::GetElemPtr {
+                    base,
+                    elem_ptr_ty,
+                    indices,
+                } => self.verify_get_elem_ptr(&ins, base, elem_ptr_ty, indices)?,
+                InstOp::GetLocal(local_var) => self.verify_get_local(local_var)?,
+                InstOp::GetConfig(_, name) => self.verify_get_config(self.cur_module, name)?,
+                InstOp::IntToPtr(value, ty) => self.verify_int_to_ptr(value, ty)?,
+                InstOp::Load(ptr) => self.verify_load(ptr)?,
+                InstOp::MemCopyBytes {
+                    dst_val_ptr,
+                    src_val_ptr,
+                    byte_len,
+                } => self.verify_mem_copy_bytes(dst_val_ptr, src_val_ptr, byte_len)?,
+                InstOp::MemCopyVal {
+                    dst_val_ptr,
+                    src_val_ptr,
+                } => self.verify_mem_copy_val(dst_val_ptr, src_val_ptr)?,
+                InstOp::Nop => (),
+                InstOp::PtrToInt(val, ty) => self.verify_ptr_to_int(val, ty)?,
+                InstOp::Ret(val, ty) => self.verify_ret(val, ty)?,
+                InstOp::Store {
+                    dst_val_ptr,
+                    stored_val,
+                } => self.verify_store(&ins, dst_val_ptr, stored_val)?,
+            };
+
+            // Verify the instruction metadata too.
+            self.context.verify_metadata(value_content.metadata)?;
         }
+
         Ok(())
     }
 
@@ -731,13 +763,15 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
 
     fn verify_get_elem_ptr(
         &self,
+        ins: &Value,
         base: &Value,
         elem_ptr_ty: &Type,
         indices: &[Value],
     ) -> Result<(), IrError> {
         use crate::constant::ConstantValue;
 
-        let base_ty = self.get_ptr_type(base, IrError::VerifyGepFromNonPointer)?;
+        let base_ty =
+            self.get_ptr_type(base, |s| IrError::VerifyGepFromNonPointer(s, Some(*ins)))?;
         if !base_ty.is_aggregate(self.context) {
             return Err(IrError::VerifyGepOnNonAggregate);
         }
@@ -747,7 +781,10 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
         };
 
         if indices.is_empty() {
-            return Err(IrError::VerifyGepInconsistentTypes);
+            return Err(IrError::VerifyGepInconsistentTypes(
+                "Empty Indices".into(),
+                Some(*base),
+            ));
         }
 
         // Fetch the field type from the vector of Values.  If the value is a constant int then
@@ -769,7 +806,14 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
         });
 
         if self.opt_ty_not_eq(&Some(elem_inner_ty), &index_ty) {
-            return Err(IrError::VerifyGepInconsistentTypes);
+            return Err(IrError::VerifyGepInconsistentTypes(
+                format!(
+                    "Element type \"{}\" versus index type {:?}",
+                    elem_inner_ty.as_string(self.context),
+                    index_ty.map(|x| x.as_string(self.context))
+                ),
+                Some(*ins),
+            ));
         }
 
         Ok(())
@@ -1021,11 +1065,16 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
         }
     }
 
-    fn verify_store(&self, dst_val: &Value, stored_val: &Value) -> Result<(), IrError> {
+    fn verify_store(
+        &self,
+        ins: &Value,
+        dst_val: &Value,
+        stored_val: &Value,
+    ) -> Result<(), IrError> {
         let dst_ty = self.get_ptr_type(dst_val, IrError::VerifyStoreToNonPointer)?;
         let stored_ty = stored_val.get_type(self.context);
         if self.opt_ty_not_eq(&Some(dst_ty), &stored_ty) {
-            Err(IrError::VerifyStoreMismatchedTypes)
+            Err(IrError::VerifyStoreMismatchedTypes(Some(*ins)))
         } else {
             Ok(())
         }
diff --git a/sway-ir/sway-ir-macros/Cargo.toml b/sway-ir/sway-ir-macros/Cargo.toml
index 0f1981375f3..f0efd249588 100644
--- a/sway-ir/sway-ir-macros/Cargo.toml
+++ b/sway-ir/sway-ir-macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-ir-macros"
-version = "0.60.0"
+version.workspace = true
 description = "Macros for sway's intermediate representation."
 authors.workspace = true
 edition.workspace = true
@@ -12,10 +12,10 @@ repository.workspace = true
 proc-macro = true
 
 [dependencies]
-itertools = "0.10.3"
-proc-macro2 = "1.0.43"
-quote = "1.0.21"
-syn = { version = "1.0.99", features = ["derive", "extra-traits"] }
+itertools.workspace = true
+proc-macro2.workspace = true
+quote.workspace = true
+syn = { workspace = true, features = ["derive", "extra-traits", "parsing"] }
 
 [lints.clippy]
 iter_over_hash_type = "deny"
diff --git a/sway-ir/sway-ir-macros/src/lib.rs b/sway-ir/sway-ir-macros/src/lib.rs
index d6bcd7a7fc5..514a3986a75 100644
--- a/sway-ir/sway-ir-macros/src/lib.rs
+++ b/sway-ir/sway-ir-macros/src/lib.rs
@@ -4,7 +4,7 @@ use {
     quote::{format_ident, quote},
     syn::{
         parse_macro_input, Attribute, Data, DeriveInput, Fields, FieldsNamed, FieldsUnnamed, Ident,
-        Meta, NestedMeta, Variant,
+        Variant,
     },
 };
 
@@ -170,7 +170,7 @@ fn pass_through_context(field_name: &Ident, attrs: &[Attribute]) -> proc_macro2:
         attrs
             .iter()
             .filter_map(|attr| {
-                let attr_name = attr.path.get_ident()?;
+                let attr_name = attr.path().get_ident()?;
                 if attr_name != "in_context" {
                     return None;
                 }
@@ -199,20 +199,16 @@ fn pass_through_context(field_name: &Ident, attrs: &[Attribute]) -> proc_macro2:
 }
 
 fn try_parse_context_field_from_attr(attr: &Attribute) -> Option<Ident> {
-    let meta = attr.parse_meta().ok()?;
-    let Meta::List(meta_list) = meta else {
-        return None;
-    };
-    if meta_list.nested.len() != 1 {
-        return None;
+    let mut context_fields = Vec::new();
+
+    let _ = attr.parse_nested_meta(|nested_meta| {
+        context_fields.push(nested_meta.path.get_ident().unwrap().clone());
+        Ok(())
+    });
+
+    if context_fields.len() != 1 {
+        None
+    } else {
+        context_fields.pop()
     }
-    let nested_meta = meta_list.nested.first()?;
-    let NestedMeta::Meta(inner_meta) = nested_meta else {
-        return None;
-    };
-    let Meta::Path(path) = inner_meta else {
-        return None;
-    };
-    let context_field_name = path.get_ident()?.clone();
-    Some(context_field_name)
 }
diff --git a/sway-ir/tests/ccp/ccp1.ir b/sway-ir/tests/ccp/ccp1.ir
new file mode 100644
index 00000000000..ad15ff80e32
--- /dev/null
+++ b/sway-ir/tests/ccp/ccp1.ir
@@ -0,0 +1,29 @@
+// regex: ID=[[:alpha:]_0-9]+
+
+script {
+    // check: fn $ID($(param=$ID): u64) -> u64
+    fn test1(p: u64) -> u64 {
+        entry(p: u64):
+        // check: $(c=$ID) = const u64 100
+        v0 = const u64 100
+        // check: cmp eq $c $param
+        v2 = cmp eq v0 p
+        // check: $ID, $(true_block=$ID)(), $(false_block=$ID)()
+        cbr v2, get_0_block0(), get_0_block1()
+
+        // check: $true_block():
+        get_0_block0():
+        // check: $(one=$ID) = const u64 1
+        v5 = const u64 1
+        // check: add $one, $c
+        v6 = add v5, p
+        ret u64 v6
+
+        // check: $false_block():
+        get_0_block1():
+        v7 = const u64 111
+        // check: add $ID, $param
+        v8 = add v7, p
+        ret u64 v8
+    }
+}
diff --git a/sway-ir/tests/cse/cse1.ir b/sway-ir/tests/cse/cse1.ir
new file mode 100644
index 00000000000..687c12f8d76
--- /dev/null
+++ b/sway-ir/tests/cse/cse1.ir
@@ -0,0 +1,21 @@
+// regex: ID=[[:alpha:]0-9]+
+// regex: VAR=v\d+
+
+script {
+    fn main() -> bool {
+        entry():
+        v0 = const u64 11
+        v1 = const u64 0
+        // check: $(v3=$VAR) = add
+        v3 = add v0, v1
+        // check: $(v4=$VAR) = add
+        v4 = add v0, v1
+        v10 = const u64 10
+        v11 = add v1, v0
+        // check: cmp eq $v3 $v3
+        v2 = cmp eq v3 v4
+        v3 = cmp eq v11 v3
+        v4 = cmp eq v2 v3
+        ret bool v4
+    }
+}
diff --git a/sway-ir/tests/cse/cse2.ir b/sway-ir/tests/cse/cse2.ir
new file mode 100644
index 00000000000..ec609f74d60
--- /dev/null
+++ b/sway-ir/tests/cse/cse2.ir
@@ -0,0 +1,22 @@
+// regex: ID=[[:alpha:]0-9]+
+// regex: VAR=v\d+
+
+script {
+    fn main() -> bool {
+        entry():
+        v0 = const u64 11
+        v0_dup = const u64 11
+        v1 = const u64 0
+        // check: $(v3=$VAR) = add        
+        v3 = add v0, v1
+        // check: $(v4=$VAR) = add        
+        v4 = add v0, v1
+        // check: $(v5=$VAR) = sub
+        v5 = sub v0, v3
+        // check: $(v6=$VAR) = sub
+        v6 = sub v0_dup, v4
+        // check: cmp eq $v5 $v5
+        v2 = cmp eq v5 v6
+        ret bool v2
+    }
+}
diff --git a/sway-ir/tests/cse/cse3.ir b/sway-ir/tests/cse/cse3.ir
new file mode 100644
index 00000000000..89a3df2fdd3
--- /dev/null
+++ b/sway-ir/tests/cse/cse3.ir
@@ -0,0 +1,29 @@
+// regex: ID=[[:alpha:]0-9]+
+// regex: VAR=v\d+
+
+script {
+    entry fn main(a: u64, b: u64) -> () {
+        entry(a: u64, b: u64):
+        // check: $(v5=$VAR) = add a, b
+        v5 = add a, b
+        v6 = const u64 0
+        br while(v6, v5)
+
+        while(v3: u64, v4: u64):
+        // check: cmp lt $VAR $v5
+        v8 = cmp lt v3 v4
+        cbr v8, while_body(), end_while()
+
+        while_body():
+        // check: $(v10=$VAR) = add a, b        
+        v10 = add a, b
+        v11 = const u64 1
+        v12 = add v3, v11
+        // check: br while($VAR, $v5)
+        br while(v12, v10)
+
+        end_while():
+        v14 = const unit ()
+        ret () v14
+    }
+}
diff --git a/sway-ir/tests/dce/copy_prop_1.ir b/sway-ir/tests/dce/copy_prop_1.ir
index b2d31c695a6..ab69f049d8f 100644
--- a/sway-ir/tests/dce/copy_prop_1.ir
+++ b/sway-ir/tests/dce/copy_prop_1.ir
@@ -18,4 +18,4 @@ script {
 
 // regex: VAL=v\d+
 
-// not: mem_copy_val $VAL, VAL
+// not: mem_copy_val $VAL, $VAL
diff --git a/sway-ir/tests/dce/dce_cast_ptr.ir b/sway-ir/tests/dce/dce_cast_ptr.ir
new file mode 100644
index 00000000000..7186ff9d92f
--- /dev/null
+++ b/sway-ir/tests/dce/dce_cast_ptr.ir
@@ -0,0 +1,37 @@
+// This test proves that the issue given in https://github.com/FuelLabs/sway/issues/6152#issuecomment-2181367848
+// is fixed. The local variable `S` does not get optimized away.
+// The local variable `dummy` is added to introduce a change in the DCE pass to
+// satisfy the testing infrastructure that expect a change after the optimization pass.
+
+script {
+    entry fn main() -> u64 {
+      local u64 S
+      local u64 dummy
+  
+      entry():
+      br block0()
+  
+      block0():
+      c0 = const u64 123
+      p = get_local ptr u64, S
+      store c0 to p
+      p_d = cast_ptr p to ptr u8
+      p_val = ptr_to_int p_d to u64
+      p_val_aug = add p_val, c0
+      p_val_res = sub p_val_aug, c0
+      res = call test(p_val_res)
+      ret u64 res
+    }
+  
+    fn test(arg: u64) -> u64 {
+      entry(arg: u64):
+      br block0(arg)
+  
+      block0(arg: ptr u64):
+      v0 = load arg
+      ret u64 v0
+    }
+}
+
+// check: entry fn main() -> u64 {
+// nextln: local u64 S
diff --git a/sway-ir/tests/dce/dce_dead_arg1.ir b/sway-ir/tests/dce/dce_dead_arg1.ir
new file mode 100644
index 00000000000..8ef051f0069
--- /dev/null
+++ b/sway-ir/tests/dce/dce_dead_arg1.ir
@@ -0,0 +1,23 @@
+// regex: ID=[[:alpha:]0-9]+
+
+script {
+    fn main() -> bool {
+        // check: entry
+        entry():
+        // not: const
+        v3v1 = const u64 0
+        v2v1 = const u64 11
+        // not: cmp
+        v4v1 = cmp eq v3v1 v2v1
+        // check: br $(block=$ID)()
+        br block0(v4v1)
+
+        // check: $block()
+        block0(v1v1: bool):
+        v6v1 = const bool false
+        // not: cmp
+        v11 = cmp eq v1v1 v6v1
+        // check: ret
+        ret bool v6v1
+    }
+}
diff --git a/sway-ir/tests/dce/dce_dead_asm_block.ir b/sway-ir/tests/dce/dce_dead_asm_block.ir
new file mode 100644
index 00000000000..3fb2f6e1403
--- /dev/null
+++ b/sway-ir/tests/dce/dce_dead_asm_block.ir
@@ -0,0 +1,184 @@
+// The IR code represents the below function.
+//
+// ASM blocks above the separation line must survive DCE because
+// their either have side-effects (or better to say, could have),
+// or their unit result is used.
+//
+// ASM blocks below the line must be optimized away.
+// The call to `function` must remain, though.
+//
+// fn main() {
+//     poke(asm() { });
+//     poke(asm() { zero });
+//     poke(asm() { zero: () });
+// 
+//     let arg = 11u64;
+//     asm(a: arg, b: arg, res) {
+//         add res a b;
+//     };
+// 
+//     asm(a: arg, b: arg, res) {
+//         add res a b;
+//         res
+//     };
+// 
+//     // -----------
+// 
+//     asm () { }
+//     asm () { zero }
+//     asm() { zero: () }
+// 
+//     asm(arg: arg) {  };
+//     asm(arg: arg) { arg };
+// 
+//     let a = asm() { };
+//     let b = asm() { zero };
+//     let c = asm(arg: arg) { };
+//     let d = asm(arg: arg) { arg };
+//     let e = asm(arg: arg) { arg: u32 };
+// 
+//     let f = asm(arg: function()) { arg };
+// }
+
+// regex: VAL=v\d+
+
+script {
+    entry fn main() -> () {
+        // check: local u64 arg
+        local u64 arg
+        // not: local () a
+        local () a
+        // not: local u64 b
+        local u64 b
+        // not: local () c
+        local () c
+        // not: local u64 d
+        local u64 d
+        // not: local u64 e
+        local u64 e
+        // not: local u64 f
+        local u64 f
+
+        // check: entry()
+        entry():
+
+        // check: = asm() -> ()
+        v0 = asm() -> () {
+        }
+        v1 = call poke_1(v0)
+
+        // check: = asm() -> u64 zero
+        v2 = asm() -> u64 zero {
+        }
+        v3 = call poke_2(v2)
+
+        // check: = asm() -> () zero
+        v4 = asm() -> () zero {
+        }
+        v5 = call poke_1(v4)
+
+        v6 = get_local ptr u64, arg
+        v7 = const u64 11
+        store v7 to v6
+        v8 = get_local ptr u64, arg
+        v9 = load v8
+        v10 = get_local ptr u64, arg
+        v11 = load v10
+
+        // check: = asm(a: $VAL, b: $VAL, res) -> ()
+        v12 = asm(a: v9, b: v11, res) -> () {
+            add    res a b
+        }
+
+        v13 = get_local ptr u64, arg
+        v14 = load v13
+        v15 = get_local ptr u64, arg
+        v16 = load v15
+
+        // check: = asm(a: $VAL, b: $VAL, res) -> u64 res
+        v17 = asm(a: v14, b: v16, res) -> u64 res {
+            add    res a b
+        }
+
+        // -----------
+        
+        // not: asm
+
+        // check: = asm() -> u64 zero
+        v2 = asm() -> u64 zero {
+        }
+        v3 = call poke_2(v2)
+
+        v18 = asm() -> () {
+        }
+        v19 = asm() -> u64 zero {
+        }
+        v20 = asm() -> () zero {
+        }
+        v21 = get_local ptr u64, arg
+        v22 = load v21
+        v23 = asm(arg: v22) -> () {
+        }
+        v24 = get_local ptr u64, arg
+        v25 = load v24
+        v26 = asm(arg: v25) -> u64 arg {
+        }
+        v27 = asm() -> () {
+        }
+        v28 = get_local ptr (), a
+        store v27 to v28
+        v29 = asm() -> u64 zero {
+        }
+        v30 = get_local ptr u64, b
+        store v29 to v30
+        v31 = get_local ptr u64, arg
+        v32 = load v31
+        v33 = asm(arg: v32) -> () {
+        }
+        v34 = get_local ptr (), c
+        store v33 to v34
+        v35 = get_local ptr u64, arg
+        v36 = load v35
+        v37 = asm(arg: v36) -> u64 arg {
+        }
+        v38 = get_local ptr u64, d
+        store v37 to v38
+        v39 = get_local ptr u64, arg
+        v40 = load v39
+        v41 = asm(arg: v40) -> u64 arg {
+        }
+        v42 = get_local ptr u64, e
+        store v41 to v42
+
+        // check: call function()
+        v43 = call function()
+        v44 = asm(arg: v43) -> u64 arg {
+        }
+        v45 = get_local ptr u64, f
+        store v44 to v45
+        v46 = const unit ()
+
+        // not: asm
+
+        // check: ret ()
+        ret () v46
+    }
+
+    fn poke_1(_x: ()) -> () {
+        entry(_x: ()):
+        v0 = const unit ()
+        ret () v0
+    }
+
+    fn poke_2(_x: u64) -> () {
+        entry(_x: u64):
+        v0 = const unit ()
+        ret () v0
+    }
+
+    fn function() -> u64 {
+        entry():
+        v0 = const u64 0
+        ret u64 v0
+    }
+}
diff --git a/sway-ir/tests/dce/dce_dead_config_assignment.ir b/sway-ir/tests/dce/dce_dead_config_assignment.ir
new file mode 100644
index 00000000000..152cb577fd0
--- /dev/null
+++ b/sway-ir/tests/dce/dce_dead_config_assignment.ir
@@ -0,0 +1,54 @@
+// The IR code represents the below function.
+// The unused local `x` must be optimized away.
+//
+// abi Abi {
+//     fn assign_config_call_pass_config();
+// }
+// 
+// configurable { CONFIG: u64 = 1234 }
+// 
+// impl Abi for Contract {
+//    fn assign_config_call_pass_config() {
+//        let x = CONFIG;
+//	      poke(CONFIG);
+//    }
+// }
+
+contract {
+    CONFIG = config u64, abi_decode_in_place_0, 0x00000000000004d2
+
+    pub fn abi_decode_in_place_0(ptr: u64, len: u64, target: u64) -> () {
+        entry(ptr: u64, len: u64, target: u64):
+        v0 = const unit ()
+        ret () v0
+    }
+
+    pub entry fn assign_config_call_pass_config<28892dec>() -> () {
+        local u64 x
+
+        entry():
+        v0 = get_config ptr u64, CONFIG
+        v1 = load v0
+        v2 = get_local ptr u64, x
+        store v1 to v2
+        v3 = get_config ptr u64, CONFIG
+        v4 = load v3
+        v5 = call poke_0(v4)
+        v6 = const unit ()
+        ret () v6
+    }
+
+    fn poke_0(_x: u64) -> () {
+        entry(_x: u64):
+        v0 = const unit ()
+        ret () v0
+    }
+}
+
+// check: pub entry fn assign_config_call_pass_config
+// nextln: entry():
+// nextln: v0 = get_config ptr u64, CONFIG
+// nextln: v1 = load v0
+// nextln: v2 = call poke_0(v1)
+// not: store
+// check: ret ()
diff --git a/sway-ir/tests/dce/dce_dead_constant_assignment.ir b/sway-ir/tests/dce/dce_dead_constant_assignment.ir
new file mode 100644
index 00000000000..0b1e5c15898
--- /dev/null
+++ b/sway-ir/tests/dce/dce_dead_constant_assignment.ir
@@ -0,0 +1,39 @@
+// The IR code represents the below function.
+// The unused local `x` must be optimized away.
+//
+// fn main() {
+//    let x = "str";
+// }
+
+script {
+    entry fn main() -> () {
+        local { u64, u64 } __anon_0
+        local slice __anon_1
+        local slice x
+
+        entry():
+        v0 = const string<3> "str"
+        v1 = ptr_to_int v0 to u64
+        v2 = get_local ptr { u64, u64 }, __anon_0
+        v3 = const u64 0
+        v4 = get_elem_ptr v2, ptr u64, v3
+        store v1 to v4
+        v5 = const u64 1
+        v6 = get_elem_ptr v2, ptr u64, v5
+        v7 = const u64 3
+        store v7 to v6
+        v8 = get_local ptr slice, __anon_1
+        mem_copy_bytes v8, v2, 16
+        v9 = load v8
+        v10 = get_local ptr slice, x
+        store v9 to v10
+        v11 = const unit ()
+        ret () v11
+    }
+}
+
+// check: entry fn main() -> () {
+// nextln: entry():
+// nextln: v0 = const unit ()
+// nextln: ret () v0
+// nextln: }
diff --git a/sway-ir/tests/dce/dce_int_to_ptr.ir b/sway-ir/tests/dce/dce_int_to_ptr.ir
new file mode 100644
index 00000000000..52453e54604
--- /dev/null
+++ b/sway-ir/tests/dce/dce_int_to_ptr.ir
@@ -0,0 +1,52 @@
+script {
+    entry fn main() -> bool {
+        local mut u64 x
+        local mut u64 y
+        local mut u64 dummy
+
+        entry():
+        v0 = const u64 0
+        v1 = const u64 2
+        v2 = cmp eq v0 v1
+        v3 = const bool false
+        v4 = cmp eq v3 v2
+        cbr v4, block0(), block1()
+
+        block0():
+        v0_0 = get_local ptr u64, x
+        v0_1 = cast_ptr v0_0 to ptr u8
+        v0_2 = cast_ptr v0_1 to ptr u64
+        v0_3 = ptr_to_int v0_2 to u64
+        v0_4 = int_to_ptr v0_3 to ptr u64
+        v0_5 = ptr_to_int v0_4 to u64
+        br block2(v0_5)
+
+        block1():
+        v1_0 = get_local ptr u64, y
+        v1_1 = cast_ptr v1_0 to ptr u8
+        v1_2 = cast_ptr v1_1 to ptr u64
+        v1_3 = ptr_to_int v1_2 to u64
+        v1_4 = int_to_ptr v1_3 to ptr u64
+        v1_5 = ptr_to_int v1_4 to u64
+        br block2(v1_5)
+
+        block2(v2_0: u64):
+        v2_1 = int_to_ptr v2_0 to ptr u64
+        v2_2 = const u64 42
+        store v2_2 to v2_1
+        v2_3 = get_local ptr u64, dummy
+        v2_4 = const u64 42
+        store v2_4 to v2_3
+        v2_5 = const bool true
+        ret bool v2_5
+    }
+}
+
+// check: local mut u64 x
+// check: local mut u64 y
+// not: local mut u64 y
+// check: block2
+// check: store
+// not: get_local ptr u64, dummy
+// not: store
+// check: ret bool
diff --git a/sway-ir/tests/dce/dce_load_from_b256.ir b/sway-ir/tests/dce/dce_load_from_b256.ir
new file mode 100644
index 00000000000..d8b9737218a
--- /dev/null
+++ b/sway-ir/tests/dce/dce_load_from_b256.ir
@@ -0,0 +1,38 @@
+// The IR code represents the below function.
+// The unused local `x` must be optimized away.
+//
+// fn main() {
+//    let local = 0x1f212e1f2e7b5a8cff18d994b7b7faa61db1a89cbf697facc518f6b6c8430196;
+//    let x = take_b256(local);
+// }
+
+script {
+    entry fn main() -> () {
+        local b256 x
+        local b256 local
+
+        entry():
+        v0 = get_local ptr b256, local
+        v1 = const b256 0x1f212e1f2e7b5a8cff18d994b7b7faa61db1a89cbf697facc518f6b6c8430196
+        store v1 to v0
+        v2 = get_local ptr b256, local
+        v3 = load v2
+        v4 = call take_b256_2(v3)
+        v5 = get_local ptr b256, x
+        store v4 to v5
+        v6 = const unit ()
+        ret () v6
+    }
+
+    fn take_b256_2(_x: b256) -> b256 {
+        entry(_x: b256):
+        v0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000
+        ret b256 v0
+    }
+}
+
+// check: entry fn main() -> () {
+// not: local b256 x
+// check: entry():
+// not: get_local ptr b256, x
+// check: ret ()
diff --git a/sway-ir/tests/dce/dce_load_from_struct.ir b/sway-ir/tests/dce/dce_load_from_struct.ir
new file mode 100644
index 00000000000..edc19d2872a
--- /dev/null
+++ b/sway-ir/tests/dce/dce_load_from_struct.ir
@@ -0,0 +1,51 @@
+// The IR code represents the below function.
+// The unused local `x` must be optimized away.
+//
+// fn main() {
+//    let local = S { x: 112233, y: 445566 };
+//    let x = take_struct(local);
+// }
+
+script {
+    entry fn main() -> () {
+        local { u64, u64 } x
+        local { u64, u64 } __anon_0
+        local { u64, u64 } local
+
+        entry():
+        v0 = get_local ptr { u64, u64 }, __anon_0
+        v1 = const u64 0
+        v2 = get_elem_ptr v0, ptr u64, v1
+        v3 = const u64 112233
+        store v3 to v2
+        v4 = const u64 1
+        v5 = get_elem_ptr v0, ptr u64, v4
+        v6 = const u64 445566
+        store v6 to v5
+        v7 = load v0
+        v8 = get_local ptr { u64, u64 }, local
+        store v7 to v8
+        v9 = get_local ptr { u64, u64 }, local
+        v10 = load v9
+        v11 = call take_struct_2(v10)
+        v12 = get_local ptr { u64, u64 }, x
+        store v11 to v12
+        v13 = const unit ()
+        ret () v13
+    }
+
+    fn take_struct_2(_x: { u64, u64 }) -> { u64, u64 } {
+        local { u64, u64 } __anon_0
+
+        entry(_x: { u64, u64 }):
+        v0 = get_local ptr { u64, u64 }, __anon_0
+        v1 = load v0
+        ret { u64, u64 } v1
+    }
+}
+
+// check: entry fn main() -> () {
+// not: local { u64, u64 } x
+// check: entry():
+// not: get_local ptr { u64, u64 }, x
+// check: ret ()
diff --git a/sway-ir/tests/demote_misc/demote_wide_binary_ops_constants.ir b/sway-ir/tests/demote_misc/demote_wide_binary_ops_constants.ir
index d326d543eb3..7a7981b0194 100644
--- a/sway-ir/tests/demote_misc/demote_wide_binary_ops_constants.ir
+++ b/sway-ir/tests/demote_misc/demote_wide_binary_ops_constants.ir
@@ -10,7 +10,6 @@ script {
     }
 }
 
-// regex: VAL=v\d+
 // regex: ID=[[:alpha:]0-9_]+
 
 // check: v0 = get_local ptr u256, __wide_lhs
diff --git a/sway-ir/tests/demote_misc/demote_wide_binary_ops_loads.ir b/sway-ir/tests/demote_misc/demote_wide_binary_ops_loads.ir
index a2ca7aaf3b5..0e159fcd627 100644
--- a/sway-ir/tests/demote_misc/demote_wide_binary_ops_loads.ir
+++ b/sway-ir/tests/demote_misc/demote_wide_binary_ops_loads.ir
@@ -12,7 +12,6 @@ script {
     }
 }
 
-// regex: VAL=v\d+
 // regex: ID=[[:alpha:]0-9_]+
 
 // check: local u256 __wide_lhs
diff --git a/sway-ir/tests/demote_misc/demote_wide_cmp_constants.ir b/sway-ir/tests/demote_misc/demote_wide_cmp_constants.ir
index c3fcd598b00..f0d43db2f21 100644
--- a/sway-ir/tests/demote_misc/demote_wide_cmp_constants.ir
+++ b/sway-ir/tests/demote_misc/demote_wide_cmp_constants.ir
@@ -8,7 +8,6 @@ script {
     }
 }
 
-// regex: VAL=v\d+
 // regex: ID=[[:alpha:]0-9_]+
 
 // check: v0 = get_local ptr u256, __wide_lhs
diff --git a/sway-ir/tests/demote_misc/demote_wide_mod_constants.ir b/sway-ir/tests/demote_misc/demote_wide_mod_constants.ir
index 5375bdf7080..d78440ef647 100644
--- a/sway-ir/tests/demote_misc/demote_wide_mod_constants.ir
+++ b/sway-ir/tests/demote_misc/demote_wide_mod_constants.ir
@@ -12,7 +12,6 @@ script {
     }
 }
 
-// regex: VAL=v\d+
 // regex: ID=[[:alpha:]0-9_]+
 
 // check: local u256 __wide_lhs
diff --git a/sway-ir/tests/demote_misc/demote_wide_not_constants.ir b/sway-ir/tests/demote_misc/demote_wide_not_constants.ir
index 46727c2dbe2..c8f08674e68 100644
--- a/sway-ir/tests/demote_misc/demote_wide_not_constants.ir
+++ b/sway-ir/tests/demote_misc/demote_wide_not_constants.ir
@@ -8,7 +8,6 @@ script {
     }
 }
 
-// regex: VAL=v\d+
 // regex: ID=[[:alpha:]0-9_]+
 
 // check: v0 = get_local ptr u256, __wide_lhs
diff --git a/sway-ir/tests/inline/big_asm_blocks.ir b/sway-ir/tests/inline/big_asm_blocks.ir
new file mode 100644
index 00000000000..4bde773b71d
--- /dev/null
+++ b/sway-ir/tests/inline/big_asm_blocks.ir
@@ -0,0 +1,104 @@
+// instrs 4
+//
+// This test proves that https://github.com/FuelLabs/sway/issues/6332 is fixed.
+//
+// `test_function`s all must be inlined because the contain only one instruction and `ret`.
+// `testf` must not be inlined. Although it has only a single `asm` instruction, that
+// one has a large number of instructions.
+
+// regex: VAR=v\d+
+// regex: LABEL=[[:alpha:]0-9_]+
+
+script {
+    // check: entry fn main() -> ()
+    entry fn main() -> () {
+        entry():
+
+        // check: call testf()
+        // not: call test_function1()
+        v0 = call test_function1()
+        
+        // check: call testf()
+        // not: call test_function2()
+        v1 = call test_function2()
+        
+        // check: call testf()
+        // not: call test_function3()
+        v2 = call test_function3()
+        v3 = const unit ()
+        ret () v3
+    }
+
+    // check: fn test_function1() -> ()
+    fn test_function1() -> () {
+        entry():
+
+        // check: call testf()
+        v0 = call testf()
+        v1 = const unit ()
+        ret () v1
+    }
+
+    // check: fn test_function2() -> bool
+    fn test_function2() -> bool {
+        entry():
+
+        // check: call testf()
+        v0 = call testf()
+        v1 = const bool true
+        ret bool v1
+    }
+
+    // check: fn test_function3() -> u64
+    fn test_function3() -> u64 {
+        entry():
+
+        // check: call testf()
+        v0 = call testf()
+        v1 = const u64 0
+        ret u64 v1
+    }
+
+    // check: fn testf() -> ()
+    fn testf() -> () {
+        entry():
+        v0 = asm(r1, r2) -> () {
+            movi   r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+            addi   r1 r2 i1
+        }
+        v1 = const unit ()
+        ret () v1
+    }
+}
diff --git a/sway-ir/tests/inline/recursive-1.ir b/sway-ir/tests/inline/recursive-1.ir
new file mode 100644
index 00000000000..b7dc13d62f3
--- /dev/null
+++ b/sway-ir/tests/inline/recursive-1.ir
@@ -0,0 +1,71 @@
+//
+// regex: VAR=v\d+
+// regex: LABEL=[[:alpha:]0-9_]+
+// regex: PING=(ping|id_from_ping)
+// regex: PONG=(pong|id_from_pong)
+script {
+
+    fn id_from_foo(b: u64) -> u64, !1 {
+       entry(b: u64):
+       ret u64 b
+    }
+
+    // check: fn foo
+    fn foo(b: u64) -> u64 {
+        entry(b: u64):
+
+        // check: call id_from_foo
+        v1 = call id_from_foo(b)
+        // check: call foo
+        v0 = call foo(v1)
+        ret u64 v0
+    }
+
+    fn id_from_ping(b: u64) -> u64, !1 {
+       entry(b: u64):
+       ret u64 b
+    }
+
+    fn id_from_pong(b: u64) -> u64, !1 {
+       entry(b: u64):
+       ret u64 b
+    }
+
+    // check: fn main
+    fn main() -> u64 {
+        entry():
+
+        v0 = const u64 11
+        // check: call foo
+        v1 = call foo(v0)
+
+        // check: $PING
+        v2 = call ping(v1)
+        v3 = add v1, v2
+
+        ret u64 v3
+    }
+
+    // check: fn ping
+    fn ping(b: u64) -> u64 {
+        entry(b: u64):
+
+        // check: id_from_ping
+        v1 = call id_from_ping(b)
+        v0 = call pong(v1)
+        ret u64 v0
+    }
+
+    // check: fn pong
+    fn pong(b: u64) -> u64 {
+        entry(b: u64):
+
+        // check: $PONG
+        v1 = call id_from_pong(b)
+        v0 = call ping(v1)
+        ret u64 v0
+    }
+
+}
+
+!1 = inline "never"
diff --git a/sway-ir/tests/memcpyopt/no_copy_prop_src_ptr_escapes.ir b/sway-ir/tests/memcpyopt/no_copy_prop_src_ptr_escapes.ir
new file mode 100644
index 00000000000..b72db62856f
--- /dev/null
+++ b/sway-ir/tests/memcpyopt/no_copy_prop_src_ptr_escapes.ir
@@ -0,0 +1,33 @@
+script {
+    entry fn main() -> u64 {
+        local u64 x
+        local u64 y
+
+        entry():
+        v0 = get_local ptr u64, x
+        v1 = get_local ptr u64, y
+	
+        v2 = load v0
+        v3 = call escape(v0) // `v0` escapes here.
+        store v2 to v1
+        v4 = load v1
+
+        ret u64 v4
+    }
+
+    fn escape(a: ptr u64) -> u64 {
+        entry(a: ptr u64):
+        z = const u64 0
+        store z to a
+        ret u64 z
+    }
+}
+
+// The `store` instruction must not be optimized away.
+
+// check: v0 = get_local ptr u64, x
+// check: v1 = get_local ptr u64, y
+// check: v2 = load v0
+// check: v3 = call escape(v0)
+// check: store v2 to v1
+// check: v4 = load v1
diff --git a/sway-ir/tests/memcpyopt/no_memcpyopt_wide_binary_operator.ir b/sway-ir/tests/memcpyopt/no_memcpyopt_wide_binary_operator.ir
new file mode 100644
index 00000000000..86b7ec464fe
--- /dev/null
+++ b/sway-ir/tests/memcpyopt/no_memcpyopt_wide_binary_operator.ir
@@ -0,0 +1,20 @@
+script {
+    entry fn main() -> u256 {
+        local u256 x
+        local u256 y
+        local u256 z
+
+        entry():
+        v0 = get_local ptr u256, x
+        v1 = get_local ptr u256, y
+        v2 = get_local ptr u256, z
+
+        mem_copy_val v2, v0
+        wide add v0, v1 to v2
+        v3 = load v2
+
+        ret u256 v3
+    }
+}
+
+// check: v3 = load v2
diff --git a/sway-ir/tests/memcpyopt/no_memcpyopt_wide_unary_operator.ir b/sway-ir/tests/memcpyopt/no_memcpyopt_wide_unary_operator.ir
new file mode 100644
index 00000000000..b2932990a02
--- /dev/null
+++ b/sway-ir/tests/memcpyopt/no_memcpyopt_wide_unary_operator.ir
@@ -0,0 +1,20 @@
+script {
+    entry fn main() -> u256 {
+        local u256 x
+        local u256 y
+        local u256 z
+
+        entry():
+        v0 = get_local ptr u256, x
+        v1 = get_local ptr u256, y
+        v2 = get_local ptr u256, z
+
+        mem_copy_val v2, v0
+        wide not v1 to v2
+        v3 = load v2
+
+        ret u256 v3
+    }
+}
+
+// check: v3 = load v2
diff --git a/sway-ir/tests/serialize/asm_block.ir b/sway-ir/tests/serialize/asm_block.ir
new file mode 100644
index 00000000000..ef37a8da783
--- /dev/null
+++ b/sway-ir/tests/serialize/asm_block.ir
@@ -0,0 +1,23 @@
+script {
+    // check: main() -> u64
+    entry fn main() -> u64 {
+        entry():
+
+        c0 = const u64 0
+
+        // check: = asm() -> () {
+        v0 = asm() -> () {
+        }
+
+        // check: = asm() -> () zero {
+        v1 = asm() -> () zero {
+        }
+
+        // check: = asm() -> u64 zero {
+        v2 = asm() -> u64 zero {
+        }
+
+        rv = const u64 0
+        ret u64 rv
+    }
+}
diff --git a/sway-ir/tests/tests.rs b/sway-ir/tests/tests.rs
index ed868159b67..197d67d400e 100644
--- a/sway-ir/tests/tests.rs
+++ b/sway-ir/tests/tests.rs
@@ -1,12 +1,15 @@
 use std::path::PathBuf;
 
+use itertools::Itertools;
 use sway_ir::{
-    create_arg_demotion_pass, create_const_demotion_pass, create_const_folding_pass,
-    create_dce_pass, create_dom_fronts_pass, create_dominators_pass, create_escaped_symbols_pass,
-    create_mem2reg_pass, create_memcpyopt_pass, create_misc_demotion_pass, create_postorder_pass,
-    create_ret_demotion_pass, create_simplify_cfg_pass, optimize as opt, register_known_passes,
-    Context, ExperimentalFlags, PassGroup, PassManager, DCE_NAME, FN_DCE_NAME,
-    FN_DEDUP_DEBUG_PROFILE_NAME, FN_DEDUP_RELEASE_PROFILE_NAME, MEM2REG_NAME, SROA_NAME,
+    create_arg_demotion_pass, create_ccp_pass, create_const_demotion_pass,
+    create_const_folding_pass, create_cse_pass, create_dce_pass, create_dom_fronts_pass,
+    create_dominators_pass, create_escaped_symbols_pass, create_mem2reg_pass,
+    create_memcpyopt_pass, create_misc_demotion_pass, create_postorder_pass,
+    create_ret_demotion_pass, create_simplify_cfg_pass, metadata_to_inline, optimize as opt,
+    register_known_passes, Context, ExperimentalFlags, Function, IrError, PassGroup, PassManager,
+    Value, DCE_NAME, FN_DCE_NAME, FN_DEDUP_DEBUG_PROFILE_NAME, FN_DEDUP_RELEASE_PROFILE_NAME,
+    MEM2REG_NAME, SROA_NAME,
 };
 use sway_types::SourceEngine;
 
@@ -73,6 +76,93 @@ fn run_tests<F: Fn(&str, &mut Context) -> bool>(sub_dir: &str, opt_fn: F) {
     }
 }
 
+// Utility for finding test files and running IR verifier tests.
+// Each test file must contain an IR code that is parsable,
+// but does not pass IR verification.
+// Each test file must contain exactly one `// error: ...` line
+// that specifies the expected IR verification error.
+fn run_ir_verifier_tests(sub_dir: &str) {
+    let source_engine = SourceEngine::default();
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    let dir: PathBuf = format!("{manifest_dir}/tests/{sub_dir}").into();
+    for entry in std::fs::read_dir(dir).unwrap() {
+        let path = entry.unwrap().path();
+
+        let input_bytes = std::fs::read(&path).unwrap();
+        let input = String::from_utf8_lossy(&input_bytes);
+
+        let expected_errors = input
+            .lines()
+            .filter(|line| line.starts_with("// error: "))
+            .collect_vec();
+
+        let expected_error = match expected_errors[..] {
+            [] => {
+                println!(
+                    "--- IR verifier test does not contain the expected error: {}",
+                    path.display()
+                );
+                println!("The expected error must be specified by using the `// error: ` comment.");
+                println!("E.g., `// error: This is the expected error`");
+                println!("There must be exactly one error specified in each IR verifier test.");
+                panic!();
+            }
+            [err] => err.replace("// error: ", ""),
+            _ => {
+                println!(
+                    "--- IR verifier test contains more then one expected error: {}",
+                    path.display()
+                );
+                println!(
+                    "There must be exactly one expected error specified in each IR verifier test."
+                );
+                println!("The specified expected errors were:");
+                println!("{}", expected_errors.join("\n"));
+                panic!();
+            }
+        };
+
+        let parse_result = sway_ir::parser::parse(
+            &input,
+            &source_engine,
+            ExperimentalFlags {
+                new_encoding: false,
+            },
+        );
+
+        match parse_result {
+            Ok(_) => {
+                println!(
+                    "--- Parsing and validating an IR verifier test passed without errors: {}",
+                    path.display()
+                );
+                println!("The expected IR validation error was: {expected_error}");
+                panic!();
+            }
+            Err(err @ IrError::ParseFailure(_, _)) => {
+                println!(
+                    "--- Parsing of an IR verifier test failed: {}",
+                    path.display()
+                );
+                println!(
+                    "IR verifier test must be parsable and result in an IR verification error."
+                );
+                println!("The parsing error was: {err}");
+                panic!();
+            }
+            Err(err) => {
+                let err = format!("{err}");
+                if !err.contains(&expected_error) {
+                    println!("--- IR verifier test failed: {}", path.display());
+                    println!("The expected error was: {expected_error}");
+                    println!("The actual IR verification error was: {err}");
+                    panic!();
+                }
+            }
+        }
+    }
+}
+
 // -------------------------------------------------------------------------------------------------
 
 #[test]
@@ -113,13 +203,18 @@ fn inline() {
                     );
 
             funcs.into_iter().fold(false, |acc, func| {
-                opt::inline_some_function_calls(
-                    ir,
-                    &func,
-                    opt::is_small_fn(max_blocks, max_instrs, max_stack),
-                )
-                .unwrap()
-                    || acc
+                let predicate = |context: &Context, function: &Function, call_site: &Value| {
+                    let attributed_inline =
+                        metadata_to_inline(context, function.get_metadata(context));
+                    match attributed_inline {
+                        Some(opt::Inline::Never) => false,
+                        Some(opt::Inline::Always) => true,
+                        None => (opt::is_small_fn(max_blocks, max_instrs, max_stack))(
+                            context, function, call_site,
+                        ),
+                    }
+                };
+                opt::inline_some_function_calls(ir, &func, predicate).unwrap() || acc
             })
         }
     })
@@ -143,6 +238,22 @@ fn constants() {
 
 // -------------------------------------------------------------------------------------------------
 
+#[allow(clippy::needless_collect)]
+#[test]
+fn ccp() {
+    run_tests("ccp", |_first_line, ir: &mut Context| {
+        let mut pass_mgr = PassManager::default();
+        let mut pass_group = PassGroup::default();
+        pass_mgr.register(create_postorder_pass());
+        pass_mgr.register(create_dominators_pass());
+        let pass = pass_mgr.register(create_ccp_pass());
+        pass_group.append_pass(pass);
+        pass_mgr.run(ir, &pass_group).unwrap()
+    })
+}
+
+// -------------------------------------------------------------------------------------------------
+
 #[allow(clippy::needless_collect)]
 #[test]
 fn simplify_cfg() {
@@ -172,6 +283,22 @@ fn dce() {
 
 // -------------------------------------------------------------------------------------------------
 
+#[allow(clippy::needless_collect)]
+#[test]
+fn cse() {
+    run_tests("cse", |_first_line, ir: &mut Context| {
+        let mut pass_mgr = PassManager::default();
+        let mut pass_group = PassGroup::default();
+        pass_mgr.register(create_postorder_pass());
+        pass_mgr.register(create_dominators_pass());
+        let pass = pass_mgr.register(create_cse_pass());
+        pass_group.append_pass(pass);
+        pass_mgr.run(ir, &pass_group).unwrap()
+    })
+}
+
+// -------------------------------------------------------------------------------------------------
+
 #[allow(clippy::needless_collect)]
 #[test]
 fn mem2reg() {
@@ -302,6 +429,11 @@ fn fndedup_release() {
     })
 }
 
+#[test]
+fn verify() {
+    run_ir_verifier_tests("verify")
+}
+
 // -------------------------------------------------------------------------------------------------
 #[test]
 fn serialize() {
diff --git a/sway-ir/tests/verify/entry_block_dominance_frontier.ir b/sway-ir/tests/verify/entry_block_dominance_frontier.ir
new file mode 100644
index 00000000000..93b95ba44b4
--- /dev/null
+++ b/sway-ir/tests/verify/entry_block_dominance_frontier.ir
@@ -0,0 +1,16 @@
+// This test proves that https://github.com/FuelLabs/sway/issues/6148 is fixed.
+
+// error: Entry block of the function "main" has predecessors. The predecessors are "block0", "block1".
+
+script {
+ fn main() -> () {
+    entry():
+    br block0()
+
+    block0():
+    br entry()
+
+    block1():
+    br entry()
+  }
+}
diff --git a/sway-ir/tests/verify/entry_block_mem2reg.ir b/sway-ir/tests/verify/entry_block_mem2reg.ir
new file mode 100644
index 00000000000..cd542e0b929
--- /dev/null
+++ b/sway-ir/tests/verify/entry_block_mem2reg.ir
@@ -0,0 +1,27 @@
+// This test proves that https://github.com/FuelLabs/sway/issues/6148 is fixed.
+
+// error: Entry block of the function "main" has a predecessor. The predecessor is "block1".
+
+script {
+  fn main(x: bool) -> u64 {
+    local u64 S = const u64 3
+
+    entry(x: bool):
+    v0 = get_local ptr u64, S
+    v1 = load v0
+    cbr x, block0(x, v1), block2(x, v1)
+
+    block0(x: bool, y: u64):
+    v0 = get_local ptr u64, S
+    v1 = const u64 1
+    store v1 to v0
+    br block1(x)
+
+    block1(x: bool):
+    z = const bool false
+    br entry(z)
+
+    block2(x: bool, y: u64):
+    ret u64 y
+  }
+}
diff --git a/sway-ir/tests/verify/entry_block_simplify_cfg.ir b/sway-ir/tests/verify/entry_block_simplify_cfg.ir
new file mode 100644
index 00000000000..f6468ad5334
--- /dev/null
+++ b/sway-ir/tests/verify/entry_block_simplify_cfg.ir
@@ -0,0 +1,10 @@
+// This test proves that https://github.com/FuelLabs/sway/issues/6148 is fixed.
+
+// error: Entry block of the function "main" has a predecessor. The predecessor is "entry".
+
+script {
+  fn main() -> bool {
+    entry():
+    br entry()
+  }
+}
diff --git a/sway-lib-core/src/codec.sw b/sway-lib-core/src/codec.sw
index bc045a460be..2e9ed4aae20 100644
--- a/sway-lib-core/src/codec.sw
+++ b/sway-lib-core/src/codec.sw
@@ -12,6 +12,17 @@ impl Buffer {
             buffer: __encode_buffer_empty(),
         }
     }
+
+    fn with_capacity(cap: u64) -> Self {
+        let ptr = asm(cap: cap) {
+            aloc cap;
+            hp: raw_ptr
+        };
+
+        Buffer {
+            buffer: (ptr, cap, 0),
+        }
+    }
 }
 
 impl AsRawSlice for Buffer {
@@ -22,12 +33,11 @@ impl AsRawSlice for Buffer {
 
 pub struct BufferReader {
     ptr: raw_ptr,
-    pos: u64,
 }
 
 impl BufferReader {
     pub fn from_parts(ptr: raw_ptr, _len: u64) -> BufferReader {
-        BufferReader { ptr, pos: 0 }
+        BufferReader { ptr }
     }
 
     pub fn from_first_parameter() -> BufferReader {
@@ -43,7 +53,6 @@ impl BufferReader {
             ptr: asm(ptr: ptr) {
                 ptr: raw_ptr
             },
-            pos: 0,
         }
     }
 
@@ -60,14 +69,13 @@ impl BufferReader {
             ptr: asm(ptr: ptr) {
                 ptr: raw_ptr
             },
-            pos: 0,
         }
     }
 
     pub fn from_script_data() -> BufferReader {
         let ptr = __gtf::<raw_ptr>(0, 0xA); // SCRIPT_DATA
         let _len = __gtf::<u64>(0, 0x4); // SCRIPT_DATA_LEN
-        BufferReader { ptr, pos: 0 }
+        BufferReader { ptr }
     }
 
     pub fn from_predicate_data() -> BufferReader {
@@ -83,56 +91,60 @@ impl BufferReader {
             0u8 => {
                 let ptr = __gtf::<raw_ptr>(predicate_index, 0x20C); // INPUT_COIN_PREDICATE_DATA
                 let _len = __gtf::<u64>(predicate_index, 0x20A); // INPUT_COIN_PREDICATE_DATA_LENGTH
-                BufferReader { ptr, pos: 0 }
+                BufferReader { ptr }
             },
             2u8 => {
                 let ptr = __gtf::<raw_ptr>(predicate_index, 0x24A); // INPUT_MESSAGE_PREDICATE_DATA
                 let _len = __gtf::<u64>(predicate_index, 0x247); // INPUT_MESSAGE_PREDICATE_DATA_LENGTH
-                BufferReader { ptr, pos: 0 }
+                BufferReader { ptr }
             },
             _ => __revert(0),
         }
     }
 
-    pub fn read_bytes(ref mut self, count: u64) -> raw_slice {
-        let next_pos = self.pos + count;
-
-        let ptr = self.ptr.add::<u8>(self.pos);
-        let slice = asm(ptr: (ptr, count)) {
-            ptr: raw_slice
+    pub fn read_8_bytes<T>(ref mut self) -> T {
+        let v = asm(ptr: self.ptr, val) {
+            lw val ptr i0;
+            val: T
         };
+        self.ptr = __ptr_add::<u8>(self.ptr, 8);
+        v
+    }
 
-        self.pos = next_pos;
+    pub fn read_32_bytes<T>(ref mut self) -> T {
+        let v = asm(ptr: self.ptr) {
+            ptr: T
+        };
+        self.ptr = __ptr_add::<u8>(self.ptr, 32);
+        v
+    }
 
+    pub fn read_bytes(ref mut self, count: u64) -> raw_slice {
+        let slice = asm(ptr: (self.ptr, count)) {
+            ptr: raw_slice
+        };
+        self.ptr = __ptr_add::<u8>(self.ptr, count);
         slice
     }
 
     pub fn read<T>(ref mut self) -> T {
-        let ptr = self.ptr.add::<u8>(self.pos);
-
         let size = __size_of::<T>();
-        let next_pos = self.pos + size;
 
         if __is_reference_type::<T>() {
-            let v = asm(ptr: ptr) {
+            let v = asm(ptr: self.ptr) {
                 ptr: T
             };
-            self.pos = next_pos;
+            self.ptr = __ptr_add::<u8>(self.ptr, size);
             v
         } else if size == 1 {
-            let v = asm(ptr: ptr, val) {
+            let v = asm(ptr: self.ptr, val) {
                 lb val ptr i0;
                 val: T
             };
-            self.pos = next_pos;
+            self.ptr = __ptr_add::<u8>(self.ptr, 1);
             v
         } else {
-            let v = asm(ptr: ptr, val) {
-                lw val ptr i0;
-                val: T
-            };
-            self.pos = next_pos;
-            v
+            self.read_8_bytes::<T>()
         }
     }
 
@@ -2521,7 +2533,7 @@ where
     }
 }
 
-// Decode 
+// Decode
 
 pub trait AbiDecode {
     fn abi_decode(ref mut buffer: BufferReader) -> Self;
@@ -2529,19 +2541,19 @@ pub trait AbiDecode {
 
 impl AbiDecode for b256 {
     fn abi_decode(ref mut buffer: BufferReader) -> b256 {
-        buffer.read::<b256>()
+        buffer.read_32_bytes::<b256>()
     }
 }
 
 impl AbiDecode for u256 {
     fn abi_decode(ref mut buffer: BufferReader) -> u256 {
-        buffer.read::<u256>()
+        buffer.read_32_bytes::<u256>()
     }
 }
 
 impl AbiDecode for u64 {
     fn abi_decode(ref mut buffer: BufferReader) -> u64 {
-        buffer.read::<u64>()
+        buffer.read_8_bytes::<u64>()
     }
 }
 
@@ -2573,23 +2585,24 @@ impl AbiDecode for u8 {
 
 impl AbiDecode for bool {
     fn abi_decode(ref mut buffer: BufferReader) -> bool {
-        buffer.read::<bool>()
+        match buffer.read::<u8>() {
+            0 => false,
+            1 => true,
+            _ => __revert(0),
+        }
     }
 }
 
 impl AbiDecode for raw_slice {
     fn abi_decode(ref mut buffer: BufferReader) -> raw_slice {
-        let len = u64::abi_decode(buffer);
-        let data = buffer.read_bytes(len);
-        asm(s: (data.ptr(), len)) {
-            s: raw_slice
-        }
+        let len = buffer.read_8_bytes::<u64>();
+        buffer.read_bytes(len)
     }
 }
 
 impl AbiDecode for str {
     fn abi_decode(ref mut buffer: BufferReader) -> str {
-        let len = u64::abi_decode(buffer);
+        let len = buffer.read_8_bytes::<u64>();
         let data = buffer.read_bytes(len);
         asm(s: (data.ptr(), len)) {
             s: str
@@ -4986,6 +4999,85 @@ where
 // END TUPLES_DECODE
 use ::ops::*;
 
+pub fn contract_call<T, TArgs>(
+    contract_id: b256,
+    method_name: str,
+    args: TArgs,
+    coins: u64,
+    asset_id: b256,
+    gas: u64,
+) -> T
+where
+    T: AbiDecode,
+    TArgs: AbiEncode,
+{
+    let first_parameter = encode(method_name);
+    let second_parameter = encode(args);
+    let params = encode((
+        contract_id,
+        asm(a: first_parameter.ptr()) {
+            a: u64
+        },
+        asm(a: second_parameter.ptr()) {
+            a: u64
+        },
+    ));
+
+    __contract_call(params.ptr(), coins, asset_id, gas);
+    let ptr = asm() {
+        ret: raw_ptr
+    };
+    let len = asm() {
+        retl: u64
+    };
+
+    let mut buffer = BufferReader::from_parts(ptr, len);
+    T::abi_decode(buffer)
+}
+
+pub fn decode_script_data<T>() -> T
+where
+    T: AbiDecode,
+{
+    let mut buffer = BufferReader::from_script_data();
+    T::abi_decode(buffer)
+}
+
+pub fn decode_predicate_data<T>() -> T
+where
+    T: AbiDecode,
+{
+    let mut buffer = BufferReader::from_predicate_data();
+    T::abi_decode(buffer)
+}
+
+pub fn decode_predicate_data_by_index<T>(index: u64) -> T
+where
+    T: AbiDecode,
+{
+    let mut buffer = BufferReader::from_predicate_data_by_index(index);
+    T::abi_decode(buffer)
+}
+
+pub fn decode_first_param<T>() -> T
+where
+    T: AbiDecode,
+{
+    let mut buffer = BufferReader::from_first_parameter();
+    T::abi_decode(buffer)
+}
+
+pub fn decode_second_param<T>() -> T
+where
+    T: AbiDecode,
+{
+    let mut buffer = BufferReader::from_second_parameter();
+    T::abi_decode(buffer)
+}
+
+// Tests
+
+
 fn assert_encoding<T, SLICE>(value: T, expected: SLICE)
 where
     T: AbiEncode,
@@ -5064,15 +5156,99 @@ fn to_slice<T>(array: T) -> raw_slice {
     raw_slice::from_parts::<u8>(__addr_of(array), len)
 }
 
-fn assert_eq<T>(a: T, b: T)
+fn assert_eq<T>(a: T, b: T, revert_code: u64)
 where
     T: Eq,
 {
     if a != b {
-        __revert(0)
+        __revert(revert_code)
     }
 }
 
+fn assert_neq<T>(a: T, b: T, revert_code: u64)
+where
+    T: Eq,
+{
+    if a == b {
+        __revert(revert_code)
+    }
+}
+
+fn assert_no_write_after_buffer<T>(value_to_append: T, size_of_t: u64)
+where
+    T: AbiEncode,
+{
+    // This red zone should not be overwritten
+    let red_zone1 = asm(size: 1024) {
+        aloc size;
+        hp: raw_ptr
+    };
+    red_zone1.write(0xFFFFFFFFFFFFFFFF);
+
+    // Create encoding buffer with capacity for one item
+    let mut buffer = Buffer::with_capacity(size_of_t);
+    let ptr1 = buffer.buffer.0;
+
+    // Append one item
+    let buffer = value_to_append.abi_encode(buffer);
+    assert_eq(ptr1, buffer.buffer.0, 1); // no buffer grow is expected
+    assert_eq(buffer.buffer.1, size_of_t, 2); // capacity must be still be one item
+    assert_eq(buffer.buffer.2, size_of_t, 3); // buffer has one item
+
+    // This red zone should not be overwritten
+    let red_zone2 = asm(size: 1024) {
+        aloc size;
+        hp: raw_ptr
+    };
+    red_zone2.write(0xFFFFFFFFFFFFFFFF);
+
+    // Append another item
+    let buffer = value_to_append.abi_encode(buffer);
+    assert_neq(ptr1, buffer.buffer.0, 4); // must have allocated new buffer
+    assert_eq(buffer.buffer.1, size_of_t * 2, 5); // capacity for two items
+    assert_eq(buffer.buffer.2, size_of_t * 2, 6); // buffer has two items
+
+    // Check that red zones were not overwritten
+    assert_eq(red_zone1.read::<u64>(), 0xFFFFFFFFFFFFFFFF, 7);
+    assert_eq(red_zone2.read::<u64>(), 0xFFFFFFFFFFFFFFFF, 8);
+}
+
+#[test]
+fn ok_encoding_should_not_write_outside_buffer() {
+    assert_no_write_after_buffer::<bool>(true, 1);
+
+    // numbers
+    assert_no_write_after_buffer::<u8>(1, 1);
+    assert_no_write_after_buffer::<u16>(1, 2);
+    assert_no_write_after_buffer::<u32>(1, 4);
+    assert_no_write_after_buffer::<u64>(1, 8);
+    assert_no_write_after_buffer::<u256>(
+        0x0000000000000000000000000000000000000000000000000000000000000001u256,
+        32,
+    );
+    assert_no_write_after_buffer::<b256>(
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+        32,
+    );
+
+    // arrays
+    assert_no_write_after_buffer::<[u8; 1]>([1], 1);
+    assert_no_write_after_buffer::<[u8; 2]>([1, 1], 2);
+    assert_no_write_after_buffer::<[u8; 3]>([1, 1, 1], 3);
+    assert_no_write_after_buffer::<[u8; 4]>([1, 1, 1, 1], 4);
+    assert_no_write_after_buffer::<[u8; 5]>([1, 1, 1, 1, 1], 5);
+
+    // string arrays
+    assert_no_write_after_buffer::<str[1]>(__to_str_array("h"), 1);
+    assert_no_write_after_buffer::<str[2]>(__to_str_array("he"), 2);
+    assert_no_write_after_buffer::<str[11]>(__to_str_array("hello world"), 11);
+
+    // string slices
+    assert_no_write_after_buffer::<str>("h", 9);
+    assert_no_write_after_buffer::<str>("he", 10);
+    assert_no_write_after_buffer::<str>("hello world", 19);
+}
+
 #[test]
 fn ok_abi_encoding() {
     // bool
@@ -5179,85 +5355,15 @@ fn ok_abi_encoding() {
     assert_encoding([255u8; 5], [255u8; 5]);
 
     let array = abi_decode::<[u8; 1]>(to_slice([255u8]));
-    assert_eq(array[0], 255u8);
+    assert_eq(array[0], 255u8, 0);
 
     let array = abi_decode::<[u8; 2]>(to_slice([255u8, 254u8]));
-    assert_eq(array[0], 255u8);
-    assert_eq(array[1], 254u8);
-}
-
-pub fn contract_call<T, TArgs>(
-    contract_id: b256,
-    method_name: str,
-    args: TArgs,
-    coins: u64,
-    asset_id: b256,
-    gas: u64,
-) -> T
-where
-    T: AbiDecode,
-    TArgs: AbiEncode,
-{
-    let first_parameter = encode(method_name);
-    let second_parameter = encode(args);
-    let params = encode((
-        contract_id,
-        asm(a: first_parameter.ptr()) {
-            a: u64
-        },
-        asm(a: second_parameter.ptr()) {
-            a: u64
-        },
-    ));
-
-    __contract_call(params.ptr(), coins, asset_id, gas);
-    let ptr = asm() {
-        ret: raw_ptr
-    };
-    let len = asm() {
-        retl: u64
-    };
-
-    let mut buffer = BufferReader::from_parts(ptr, len);
-    T::abi_decode(buffer)
+    assert_eq(array[0], 255u8, 0);
+    assert_eq(array[1], 254u8, 0);
 }
 
-pub fn decode_script_data<T>() -> T
-where
-    T: AbiDecode,
-{
-    let mut buffer = BufferReader::from_script_data();
-    T::abi_decode(buffer)
-}
-
-pub fn decode_predicate_data<T>() -> T
-where
-    T: AbiDecode,
-{
-    let mut buffer = BufferReader::from_predicate_data();
-    T::abi_decode(buffer)
-}
-
-pub fn decode_predicate_data_by_index<T>(index: u64) -> T
-where
-    T: AbiDecode,
-{
-    let mut buffer = BufferReader::from_predicate_data_by_index(index);
-    T::abi_decode(buffer)
-}
-
-pub fn decode_first_param<T>() -> T
-where
-    T: AbiDecode,
-{
-    let mut buffer = BufferReader::from_first_parameter();
-    T::abi_decode(buffer)
-}
-
-pub fn decode_second_param<T>() -> T
-where
-    T: AbiDecode,
-{
-    let mut buffer = BufferReader::from_second_parameter();
-    T::abi_decode(buffer)
+#[test(should_revert)]
+fn nok_abi_encoding_invalid_bool() {
+    let actual = encode(2u8);
+    let _ = abi_decode::<bool>(actual);
 }
diff --git a/sway-lib-core/src/lib.sw b/sway-lib-core/src/lib.sw
index 9bec5cc9bd9..4437bdd85cb 100644
--- a/sway-lib-core/src/lib.sw
+++ b/sway-lib-core/src/lib.sw
@@ -3,6 +3,7 @@ library;
 pub mod primitives;
 pub mod raw_ptr;
 pub mod raw_slice;
+pub mod slice;
 pub mod r#str;
 pub mod ops;
 pub mod primitive_conversions;
diff --git a/sway-lib-core/src/ops.sw b/sway-lib-core/src/ops.sw
index 1229ca8e649..371bbff5382 100644
--- a/sway-lib-core/src/ops.sw
+++ b/sway-lib-core/src/ops.sw
@@ -1,6 +1,7 @@
 library;
 
 use ::primitives::*;
+use ::slice::*;
 
 /// Trait for the addition of two values.
 pub trait Add {
@@ -58,9 +59,15 @@ impl Add for u32 {
         // any non-64-bit value is compiled to a u64 value under-the-hood
         // constants (like Self::max() below) are also automatically promoted to u64
         let res = __add(self, other);
+        // integer overflow
         if __gt(res, Self::max()) {
-            // integer overflow
-            __revert(0)
+            if panic_on_overflow_is_enabled() {
+                __revert(0)
+            } else {
+                // overflow enabled
+                // res % (Self::max() + 1)
+                __mod(res, __add(Self::max(), 1))
+            }
         } else {
             // no overflow
             res
@@ -72,7 +79,13 @@ impl Add for u16 {
     fn add(self, other: Self) -> Self {
         let res = __add(self, other);
         if __gt(res, Self::max()) {
-            __revert(0)
+            if panic_on_overflow_is_enabled() {
+                __revert(0)
+            } else {
+                // overflow enabled
+                // res % (Self::max() + 1)
+                __mod(res, __add(Self::max(), 1))
+            }
         } else {
             res
         }
@@ -92,7 +105,16 @@ impl Add for u8 {
             input: u64
         };
         if __gt(res_u64, max_u8_u64) {
-            __revert(0)
+            if panic_on_overflow_is_enabled() {
+                __revert(0)
+            } else {
+                // overflow enabled
+                // res % (Self::max() + 1)
+                let res_u64 = __mod(res_u64, __add(max_u8_u64, 1));
+                asm(input: res_u64) {
+                    input: u8
+                }
+            }
         } else {
             asm(input: res_u64) {
                 input: u8
@@ -228,8 +250,14 @@ impl Multiply for u32 {
         // constants (like Self::max() below) are also automatically promoted to u64
         let res = __mul(self, other);
         if __gt(res, Self::max()) {
-            // integer overflow
-            __revert(0)
+            if panic_on_overflow_is_enabled() {
+                // integer overflow
+                __revert(0)
+            } else {
+                // overflow enabled
+                // res % (Self::max() + 1)
+                __mod(res, __add(Self::max(), 1))
+            }
         } else {
             // no overflow
             res
@@ -241,7 +269,11 @@ impl Multiply for u16 {
     fn multiply(self, other: Self) -> Self {
         let res = __mul(self, other);
         if __gt(res, Self::max()) {
-            __revert(0)
+            if panic_on_overflow_is_enabled() {
+                __revert(0)
+            } else {
+                __mod(res, __add(Self::max(), 1))
+            }
         } else {
             res
         }
@@ -261,7 +293,16 @@ impl Multiply for u8 {
             input: u64
         };
         if __gt(res_u64, max_u8_u64) {
-            __revert(0)
+            if panic_on_overflow_is_enabled() {
+                __revert(0)
+            } else {
+                // overflow enabled
+                // res % (Self::max() + 1)
+                let res_u64 = __mod(res_u64, __add(max_u8_u64, 1));
+                asm(input: res_u64) {
+                    input: u8
+                }
+            }
         } else {
             asm(input: res_u64) {
                 input: u8
@@ -1174,6 +1215,122 @@ impl Shift for u16 {
     }
 }
 
+/// Trait to compare values of the same type.
+pub trait TotalOrd {
+    /// Finds the minimum value of two values of the same type.
+    ///
+    /// # Arguments
+    ///
+    /// * `other`: [Self] - The value of the same type.
+    ///
+    /// # Returns
+    ///
+    /// * Self - the minimum of the two values, or the same value if they are equal.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// struct MyStruct {
+    ///     val: u64,
+    /// }
+    ///
+    /// impl TotalOrd for MyStruct {
+    ///     fn min(self, other: Self) -> Self {
+    ///         if self.val < other.val { self } else { other }
+    ///     }
+    /// }
+    ///
+    /// fn foo() {
+    ///     let struct1 = MyStruct { val: 10 };
+    ///     let struct2 = MyStruct { val: 20 };
+    ///     let min = struct1.min(struct2);
+    ///     assert(min.val == struct1.val);
+    /// }
+    /// ```
+    fn min(self, other: Self) -> Self;
+    /// Finds the maximum value of two values of the same type.
+    ///
+    /// # Arguments
+    ///
+    /// * `other`: [Self] - The value of the same type.
+    ///
+    /// # Returns
+    ///
+    /// * Self - the maximum of the two values, or the same value if they are equal.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// struct MyStruct {
+    ///     val: u64,
+    /// }
+    ///
+    /// impl TotalOrd for MyStruct {
+    ///     fn max(self, other: Self) -> Self {
+    ///         if self.val > other.val { self } else { other }
+    ///     }
+    /// }
+    ///
+    /// fn foo() {
+    ///     let struct1 = MyStruct { val: 10 };
+    ///     let struct2 = MyStruct { val: 20 };
+    ///     let max = struct1.max(struct2);
+    ///     assert(max.val == struct2.val);
+    /// }
+    /// ```
+    fn max(self, other: Self) -> Self;
+}
+
+impl TotalOrd for u8 {
+    fn min(self, other: Self) -> Self {
+        if self < other { self } else { other }
+    }
+
+    fn max(self, other: Self) -> Self {
+        if self > other { self } else { other }
+    }
+}
+
+impl TotalOrd for u16 {
+    fn min(self, other: Self) -> Self {
+        if self < other { self } else { other }
+    }
+
+    fn max(self, other: Self) -> Self {
+        if self > other { self } else { other }
+    }
+}
+
+impl TotalOrd for u32 {
+    fn min(self, other: Self) -> Self {
+        if self < other { self } else { other }
+    }
+
+    fn max(self, other: Self) -> Self {
+        if self > other { self } else { other }
+    }
+}
+
+impl TotalOrd for u64 {
+    fn min(self, other: Self) -> Self {
+        if self < other { self } else { other }
+    }
+
+    fn max(self, other: Self) -> Self {
+        if self > other { self } else { other }
+    }
+}
+
+impl TotalOrd for u256 {
+    fn min(self, other: Self) -> Self {
+        if self < other { self } else { other }
+    }
+
+    fn max(self, other: Self) -> Self {
+        if self > other { self } else { other }
+    }
+}
+
 impl Shift for u8 {
     fn lsh(self, other: u64) -> Self {
         __and(__lsh(self, other), Self::max())
@@ -1257,3 +1414,19 @@ pub fn ok_str_eq() {
     assert("" != "a");
     assert("a" != "b");
 }
+
+fn flags() -> u64 {
+    asm() {
+        flag
+    }
+}
+
+fn panic_on_overflow_is_enabled() -> bool {
+    __eq(
+        __and(
+            flags(),
+            0b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000010,
+        ),
+        0,
+    )
+}
diff --git a/sway-lib-core/src/prelude.sw b/sway-lib-core/src/prelude.sw
index 83fbeaa8627..cdec0239241 100644
--- a/sway-lib-core/src/prelude.sw
+++ b/sway-lib-core/src/prelude.sw
@@ -3,12 +3,12 @@ library;
 //! Defines the Sway core library prelude.
 //! The prelude consists of implicitly available items,
 //! for which `use` is not required.
-use ::primitives::*;
-use ::primitive_conversions::*;
-use ::raw_ptr::*;
-use ::raw_slice::*;
-use ::never::*;
-use ::ops::*;
-use ::storage::*;
-use ::str::*;
-use ::codec::*;
+pub use ::primitives::*;
+pub use ::primitive_conversions::*;
+pub use ::raw_ptr::*;
+pub use ::raw_slice::*;
+pub use ::never::*;
+pub use ::ops::*;
+pub use ::storage::*;
+pub use ::str::*;
+pub use ::codec::*;
diff --git a/sway-lib-core/src/slice.sw b/sway-lib-core/src/slice.sw
new file mode 100644
index 00000000000..c2a19246696
--- /dev/null
+++ b/sway-lib-core/src/slice.sw
@@ -0,0 +1,19 @@
+library;
+
+use ::raw_ptr::*;
+
+impl<T> &__slice[T] {
+    pub fn ptr(self) -> raw_ptr {
+        let (ptr, _) = asm(s: self) {
+            s: (raw_ptr, u64)
+        };
+        ptr
+    }
+
+    pub fn len(self) -> u64 {
+        let (_, len) = asm(s: self) {
+            s: (raw_ptr, u64)
+        };
+        len
+    }
+}
diff --git a/sway-lib-std/src/alloc.sw b/sway-lib-std/src/alloc.sw
index 9841fe5e1e1..bd3dd7cc095 100644
--- a/sway-lib-std/src/alloc.sw
+++ b/sway-lib-std/src/alloc.sw
@@ -112,10 +112,9 @@ pub fn realloc<T>(ptr: raw_ptr, count: u64, new_count: u64) -> raw_ptr {
 /// }
 /// ```
 pub fn alloc_bytes(count: u64) -> raw_ptr {
-    asm(size: count, ptr) {
+    asm(size: count) {
         aloc size;
-        move ptr hp;
-        ptr: raw_ptr
+        hp: raw_ptr
     }
 }
 
diff --git a/sway-lib-std/src/asset.sw b/sway-lib-std/src/asset.sw
index b5f98fdfd52..461bcd73399 100644
--- a/sway-lib-std/src/asset.sw
+++ b/sway-lib-std/src/asset.sw
@@ -9,6 +9,7 @@ use ::error_signals::FAILED_TRANSFER_TO_ADDRESS_SIGNAL;
 use ::identity::Identity;
 use ::revert::revert;
 use ::outputs::{Output, output_amount, output_count, output_type};
+use ::option::Option::{self, *};
 
 /// Mint `amount` coins of the current contract's `asset_id` and transfer them to `to` by calling `transfer()`.
 ///
@@ -192,10 +193,10 @@ fn transfer_to_address(to: Address, asset_id: AssetId, amount: u64) {
     // If an output of type `OutputVariable` is found, check if its `amount` is
     // zero. As one cannot transfer zero coins to an output without a panic, a
     // variable output with a value of zero is by definition unused.
-    let number_of_outputs = output_count();
+    let number_of_outputs = output_count().as_u64();
     while index < number_of_outputs {
-        if let Output::Variable = output_type(index) {
-            if output_amount(index) == 0 {
+        if let Some(Output::Variable) = output_type(index) {
+            if let Some(0) = output_amount(index) {
                 asm(r1: to.bits(), r2: index, r3: amount, r4: asset_id) {
                     tro r1 r2 r3 r4;
                 };
diff --git a/sway-lib-std/src/auth.sw b/sway-lib-std/src/auth.sw
index 3bc964de70e..b2f37dc6dd9 100644
--- a/sway-lib-std/src/auth.sw
+++ b/sway-lib-std/src/auth.sw
@@ -6,7 +6,16 @@ use ::contract_id::ContractId;
 use ::identity::Identity;
 use ::option::Option::{self, *};
 use ::result::Result::{self, *};
-use ::inputs::{Input, input_coin_owner, input_count, input_type};
+use ::inputs::{
+    Input,
+    input_coin_owner,
+    input_count,
+    input_message_recipient,
+    input_message_sender,
+    input_type,
+};
+use ::revert::revert;
+use ::vec::Vec;
 
 /// The error type used when an `Identity` cannot be determined.
 pub enum AuthError {
@@ -132,38 +141,51 @@ pub fn msg_sender() -> Result<Identity, AuthError> {
 /// }
 /// ```
 pub fn caller_address() -> Result<Address, AuthError> {
-    let inputs = input_count();
+    // Note: `input_count()` is guaranteed to be at least 1 for any valid tx.
+    let inputs = input_count().as_u64();
     let mut candidate = None;
-    let mut i = 0u16;
+    let mut iter = 0;
 
-    // Note: `inputs_count` is guaranteed to be at least 1 for any valid tx.
-    while i < inputs {
-        let type_of_input = input_type(i.as_u64());
+    while iter < inputs {
+        let type_of_input = input_type(iter);
         match type_of_input {
-            Input::Coin => (),
-            Input::Message => (),
+            Some(Input::Coin) => (),
+            Some(Input::Message) => (),
             _ => {
                 // type != InputCoin or InputMessage, continue looping.
-                i += 1u16;
+                iter += 1;
                 continue;
             }
         }
 
         // type == InputCoin or InputMessage.
-        let owner_of_input = input_coin_owner(i.as_u64());
+        let owner_of_input = match type_of_input {
+            Some(Input::Coin) => {
+                input_coin_owner(iter)
+            },
+            Some(Input::Message) => {
+                input_message_recipient(iter)
+            },
+            _ => {
+                // type != InputCoin or InputMessage, continue looping.
+                iter += 1;
+                continue;
+            }
+        };
+
         if candidate.is_none() {
             // This is the first input seen of the correct type.
             candidate = owner_of_input;
-            i += 1u16;
+            iter += 1;
             continue;
         }
 
         // Compare current input owner to candidate.
-        // `candidate` and `input_coin_owner` must be `Some`.
+        // `candidate` and `owner_of_input` must be `Some`.
         // at this point, so we can unwrap safely.
         if owner_of_input.unwrap() == candidate.unwrap() {
             // Owners are a match, continue looping.
-            i += 1u16;
+            iter += 1;
             continue;
         }
 
@@ -178,15 +200,57 @@ pub fn caller_address() -> Result<Address, AuthError> {
     }
 }
 
-/// Get the current predicate's address when called in an internal context.
+/// Get the owners of the inputs (of type `Input::Coin` or `Input::Message`) to a
+/// `TransactionScript`.
+///
+/// # Additional Information
+///
+/// The list is not deduplicated, so there may be repeated addresses in the returned vector.
 ///
 /// # Returns
 ///
-/// * [Address] - The address of this predicate.
+/// * [Vec<Address>] - The addresses of the owners of the inputs.
+///
+/// # Examples
+///
+/// ```sway
+/// use std::auth::caller_addresses;
+///
+/// fn foo(some_address: Address) {
+///     let addresses = caller_addresses();
+///
+///     assert(addresses.get(0).unwrap() == some_address);
+/// }
+/// ```
+pub fn caller_addresses() -> Vec<Address> {
+    let inputs = input_count().as_u64();
+    let mut addresses = Vec::new();
+    let mut iter = 0;
+
+    while iter < inputs {
+        // Call the corresponding function based on the input type.
+        let input_owner = match input_type(iter) {
+            Some(Input::Coin) => input_coin_owner(iter),
+            Some(Input::Message) => input_message_recipient(iter),
+            _ => None, // If not Coin or Message, loop continues.
+        };
+
+        // If we successfully retrieved an owner address, add it to the vector.
+        if let Some(address) = input_owner {
+            addresses.push(address);
+        }
+
+        iter += 1;
+    }
+
+    addresses
+}
+
+/// Get the current predicate's address when called in an internal context.
 ///
-/// # Reverts
+/// # Returns
 ///
-/// * When called outside of a predicate program.
+/// * [Option<Address>] - The address of this predicate.
 ///
 /// # Examples
 ///
@@ -194,11 +258,11 @@ pub fn caller_address() -> Result<Address, AuthError> {
 /// use std::auth::predicate_address;
 ///
 /// fn main() {
-///     let this_predicate = predicate_address();
+///     let this_predicate = predicate_address().unwrap();
 ///     log(this_predicate);
 /// }
 /// ```
-pub fn predicate_address() -> Address {
+pub fn predicate_address() -> Option<Address> {
     // Get index of current predicate.
     // i3 = GM_GET_VERIFYING_PREDICATE
     let predicate_index = asm(r1) {
@@ -206,5 +270,13 @@ pub fn predicate_address() -> Address {
         r1: u64
     };
 
-    input_coin_owner(predicate_index).unwrap()
+    let type_of_input = input_type(predicate_index);
+
+    match type_of_input {
+        Some(Input::Coin) => input_coin_owner(predicate_index),
+        Some(Input::Message) => input_message_recipient(predicate_index),
+        _ => {
+            None
+        }
+    }
 }
diff --git a/sway-lib-std/src/bytes.sw b/sway-lib-std/src/bytes.sw
index b3efba7f4b5..1296e940826 100644
--- a/sway-lib-std/src/bytes.sw
+++ b/sway-lib-std/src/bytes.sw
@@ -74,14 +74,16 @@ impl From<raw_slice> for RawBytes {
     /// assert(raw_bytes.capacity == 3);
     /// ```
     fn from(slice: raw_slice) -> Self {
-        Self {
-            ptr: slice.ptr(),
-            cap: slice.number_of_bytes(),
+        let cap = slice.number_of_bytes();
+        let ptr = alloc_bytes(cap);
+        if cap > 0 {
+            slice.ptr().copy_to::<u8>(ptr, cap);
         }
+        Self { ptr, cap }
     }
 }
 
-/// A type used to represent raw bytes.
+/// A type used to represent raw bytes. It has ownership over its buffer.
 pub struct Bytes {
     /// A barebones struct for the bytes.
     buf: RawBytes,
@@ -415,7 +417,7 @@ impl Bytes {
 
         // Shift everything down to fill in that spot.
         let mut i = index;
-        while i < self.len {
+        while i < self.len - 1 {
             let idx_ptr = start.add_uint_offset(i);
             let next = idx_ptr.add_uint_offset(1);
             next.copy_bytes_to(idx_ptr, 1);
@@ -651,7 +653,12 @@ impl Bytes {
         (left_bytes, right_bytes)
     }
 
-    /// Moves all elements of `other` into `self`, leaving `other` empty.
+    /// Copies all elements of `other` into `self`
+    ///
+    /// # Additional Information
+    ///
+    /// NOTE: Appending `self` to itself will duplicate the `Bytes`. i.e. [0, 1, 2] => [0, 1, 2, 0, 1, 2]
+    /// This function differs from the rust `append` function in that it does not clear the `other` `Bytes`
     ///
     /// # Arguments
     ///
@@ -694,7 +701,6 @@ impl Bytes {
         // optimization for when starting with empty bytes and appending to it
         if self.len == 0 {
             self = other;
-            other.clear();
             return;
         };
 
@@ -715,19 +721,16 @@ impl Bytes {
 
         // set capacity and length
         self.len = both_len;
-
-        // clear `other`
-        other.clear();
     }
 }
 
 impl core::ops::Eq for Bytes {
     fn eq(self, other: Self) -> bool {
-        if self.len != other.len() {
+        if self.len != other.len {
             return false;
         }
 
-        asm(result, r2: self.buf.ptr(), r3: other.ptr(), r4: self.len) {
+        asm(result, r2: self.buf.ptr, r3: other.buf.ptr, r4: self.len) {
             meq result r2 r3 r4;
             result: bool
         }
@@ -737,7 +740,7 @@ impl core::ops::Eq for Bytes {
 impl AsRawSlice for Bytes {
     /// Returns a raw slice of all of the elements in the type.
     fn as_raw_slice(self) -> raw_slice {
-        asm(ptr: (self.buf.ptr(), self.len)) {
+        asm(ptr: (self.buf.ptr, self.len)) {
             ptr: raw_slice
         }
     }
@@ -750,7 +753,7 @@ impl From<b256> for Bytes {
         let mut bytes = Self::with_capacity(32);
         bytes.len = 32;
         // Copy bytes from contract_id into the buffer of the target bytes
-        __addr_of(b).copy_bytes_to(bytes.buf.ptr(), 32);
+        __addr_of(b).copy_bytes_to(bytes.buf.ptr, 32);
 
         bytes
     }
@@ -826,9 +829,7 @@ impl From<Bytes> for raw_slice {
     /// assert(slice.number_of_bytes() == 3);
     /// ```
     fn from(bytes: Bytes) -> raw_slice {
-        asm(ptr: (bytes.buf.ptr(), bytes.len)) {
-            ptr: raw_slice
-        }
+        bytes.as_raw_slice()
     }
 }
 
@@ -906,38 +907,47 @@ impl From<Bytes> for Vec<u8> {
 impl Clone for Bytes {
     fn clone(self) -> Self {
         let len = self.len();
-        let mut c = Self::with_capacity(len);
-        c.len = len;
-        self.ptr().copy_bytes_to(c.ptr(), len);
-        c
+        let buf = RawBytes::with_capacity(len);
+        if len > 0 {
+            self.ptr().copy_bytes_to(buf.ptr(), len);
+        }
+        Bytes { buf, len }
     }
 }
 
 impl AbiEncode for Bytes {
     fn abi_encode(self, buffer: Buffer) -> Buffer {
-        let mut buffer = self.len.abi_encode(buffer);
-
-        let mut i = 0;
-        while i < self.len {
-            let item = self.get(i).unwrap();
-            buffer = item.abi_encode(buffer);
-            i += 1;
-        }
-
-        buffer
+        self.as_raw_slice().abi_encode(buffer)
     }
 }
 
 impl AbiDecode for Bytes {
     fn abi_decode(ref mut buffer: BufferReader) -> Bytes {
-        let len = u64::abi_decode(buffer);
-        let data = buffer.read_bytes(len);
-        Bytes {
-            buf: RawBytes {
-                ptr: data.ptr(),
-                cap: len,
-            },
-            len,
-        }
+        raw_slice::abi_decode(buffer).into()
     }
 }
+
+// TODO: Uncomment when fixed. https://github.com/FuelLabs/sway/issues/6567
+// #[test]
+// fn ok_bytes_buffer_ownership() {
+//     let mut original_array = [1u8, 2u8, 3u8, 4u8];
+//     let slice = raw_slice::from_parts::<u8>(__addr_of(original_array), 4);
+
+//     // Check Bytes duplicates the original slice
+//     let mut bytes = Bytes::from(slice);
+//     bytes.set(0, 5);
+//     assert(original_array[0] == 1);
+
+//     // At this point, slice equals [5, 2, 3, 4]
+//     let encoded_slice = encode(bytes);
+
+//     // `Bytes` should duplicate the underlying buffer,
+//     // so when we write to it, it should not change
+//     // `encoded_slice` 
+//     let mut bytes = abi_decode::<Bytes>(encoded_slice);
+//     bytes.set(0, 6);
+//     assert(bytes.get(0) == Some(6));
+
+//     let mut bytes = abi_decode::<Bytes>(encoded_slice);
+//     assert(bytes.get(0) == Some(5));
+// }
diff --git a/sway-lib-std/src/call_frames.sw b/sway-lib-std/src/call_frames.sw
index 8d69188204d..21b009659c3 100644
--- a/sway-lib-std/src/call_frames.sw
+++ b/sway-lib-std/src/call_frames.sw
@@ -63,10 +63,11 @@ pub fn msg_asset_id() -> AssetId {
 /// }
 /// ```
 pub fn code_size() -> u64 {
-    asm(size, ptr, offset: 576) {
+    let ptr = asm(size, ptr, offset: 576) {
         add size fp offset;
-        size: u64
-    }
+        size: raw_ptr
+    };
+    ptr.read::<u64>()
 }
 
 /// Get the first parameter from the current call frame.
diff --git a/sway-lib-std/src/ecr.sw b/sway-lib-std/src/ecr.sw
index 1bff86d3be9..236703603fa 100644
--- a/sway-lib-std/src/ecr.sw
+++ b/sway-lib-std/src/ecr.sw
@@ -3,6 +3,7 @@ library;
 
 use ::address::Address;
 use ::b512::B512;
+use ::bytes::Bytes;
 use ::registers::error;
 use ::hash::*;
 use ::result::Result::{self, *};
@@ -11,6 +12,8 @@ use ::result::Result::{self, *};
 pub enum EcRecoverError {
     /// The error variant used when the recover fails.
     UnrecoverablePublicKey: (),
+    /// The length of the message is zero.
+    ZeroLengthMessage: (),
 }
 
 /// Recover the public key derived from the private key used to sign a message.
@@ -129,8 +132,8 @@ pub fn ec_recover_r1(signature: B512, msg_hash: b256) -> Result<B512, EcRecoverE
 /// # Arguments
 ///
 /// * `public_key`: [b256] - The public key that signed the message.
-/// * `signature`: [B512] - The signature generated by signing a message hash.
-/// * `msg_hash`: [b256] - The hashed signed data.
+/// * `signature`: [B512] - The signature generated by signing a message.
+/// * `msg`: [Bytes] - The signed data.
 ///
 /// # Returns
 ///
@@ -139,7 +142,7 @@ pub fn ec_recover_r1(signature: B512, msg_hash: b256) -> Result<B512, EcRecoverE
 /// # Examples
 ///
 /// ```sway
-/// use std::{ecr::ed_verify, b512::B512};
+/// use std::{ecr::ed_verify, b512::B512, bytes::Bytes};
 ///
 /// fn foo() {
 ///     let pub_key = 0x314fa58689bbe1da2430517de2d772b384a1c1d2e9cb87e73c6afcf246045b10;
@@ -150,21 +153,24 @@ pub fn ec_recover_r1(signature: B512, msg_hash: b256) -> Result<B512, EcRecoverE
 ///     let lo = 0xf5084560039486d3462dd65a40c80a74709b2f06d450ffc5dc00345c6b2cdd00;
 ///     let signature: B512 = B512::from((hi, lo));
 ///     // A verified public key with signature
-///     let verified = ed_verify(pub_key, signature, msg_hash).unwrap();
+///     let verified = ed_verify(pub_key, signature, Bytes::from(msg_hash)).unwrap();
 ///     assert(verified);
 /// }
 /// ```
-pub fn ed_verify(
-    public_key: b256,
-    signature: B512,
-    msg_hash: b256,
-) -> Result<bool, EcRecoverError> {
+pub fn ed_verify(public_key: b256, signature: B512, msg: Bytes) -> Result<bool, EcRecoverError> {
+    let len = msg.len();
+
+    if len == 0 {
+        return Err(EcRecoverError::ZeroLengthMessage);
+    };
+
     let was_error = asm(
         buffer: public_key,
         sig: __addr_of(signature),
-        hash: msg_hash,
+        msg: msg.ptr(),
+        len: len,
     ) {
-        ed19 buffer sig hash;
+        ed19 buffer sig msg len;
         err
     };
     // check the $err register to see if the `ed19` opcode succeeded
diff --git a/sway-lib-std/src/execution.sw b/sway-lib-std/src/execution.sw
index f5a03395793..759053a8b1d 100644
--- a/sway-lib-std/src/execution.sw
+++ b/sway-lib-std/src/execution.sw
@@ -23,7 +23,7 @@ pub fn run_external(load_target: ContractId) -> ! {
         move ssp_saved ssp;
         sub cur_stack_size sp ssp;
         cfs cur_stack_size;
-        ldc load_target zero length;
+        ldc load_target zero length i0;
         addi word zero i64;
         aloc word;
         sw hp ssp_saved i0;
diff --git a/sway-lib-std/src/flags.sw b/sway-lib-std/src/flags.sw
index 7f1d012b152..956f5024218 100644
--- a/sway-lib-std/src/flags.sw
+++ b/sway-lib-std/src/flags.sw
@@ -4,13 +4,13 @@ library;
 use ::{assert::assert, logging::log, registers::{error, flags}};
 
 // Mask second bit, which is `F_WRAPPING`.
-const F_WRAPPING_DISABLE_MASK: u64 = 0b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000010;
+pub const F_WRAPPING_DISABLE_MASK: u64 = 0b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000010;
 // Mask second bit, which is `F_WRAPPING`.
-const F_WRAPPING_ENABLE_MASK: u64 = 0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111101;
+pub const F_WRAPPING_ENABLE_MASK: u64 = 0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111101;
 // Mask first bit, which is `F_UNSAFEMATH`.
-const F_UNSAFEMATH_DISABLE_MASK: u64 = 0b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001;
+pub const F_UNSAFEMATH_DISABLE_MASK: u64 = 0b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001;
 // Mask first bit, which is `F_UNSAFEMATH`.
-const F_UNSAFEMATH_ENABLE_MASK: u64 = 0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111110;
+pub const F_UNSAFEMATH_ENABLE_MASK: u64 = 0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111110;
 
 /// Sets the flag register to the given value.
 ///
@@ -210,3 +210,45 @@ pub fn enable_panic_on_unsafe_math() {
         flag flag_val;
     }
 }
+
+/// Checks if the `panic-on-overflow` flag is set in the FuelVM.
+///
+/// # Returns
+///
+/// * [bool] - `true` if `panic-on-overflow` is enabled. `false` otherwise.
+///
+/// # Examples
+///
+/// ```sway
+/// use std::flags::panic_on_overflow_enabled;
+///
+/// fn main() {
+///     let is_enabled = panic_on_overflow_enabled();
+///     // Panic on overflow is enabled by default.
+///     assert(is_enabled);
+/// }
+/// ```
+pub fn panic_on_overflow_enabled() -> bool {
+    (flags() & F_WRAPPING_DISABLE_MASK) == 0
+}
+
+/// Checks if the `panic-on-unsafe-math` flag is set in the FuelVM.
+///
+/// # Returns
+///
+/// * [bool] - `true` if `panic-on-unsafe-math` is enabled. `false` otherwise.
+///
+/// # Examples
+///
+/// ```sway
+/// use std::flags::panic_on_unsafe_math_enabled;
+///
+/// fn main() {
+///     let is_enabled = panic_on_unsafe_math_enabled();
+///     // Panic on unsafe math is enabled by default.
+///     assert(is_enabled);
+/// }
+/// ```
+pub fn panic_on_unsafe_math_enabled() -> bool {
+    (flags() & F_UNSAFEMATH_DISABLE_MASK) == 0
+}
diff --git a/sway-lib-std/src/inputs.sw b/sway-lib-std/src/inputs.sw
index 622041e8d5f..f4db2869bb2 100644
--- a/sway-lib-std/src/inputs.sw
+++ b/sway-lib-std/src/inputs.sw
@@ -9,7 +9,6 @@ use ::asset_id::AssetId;
 use ::bytes::Bytes;
 use ::contract_id::ContractId;
 use ::option::Option::{self, *};
-use ::revert::revert;
 use ::tx::{
     GTF_CREATE_INPUT_AT_INDEX,
     GTF_CREATE_INPUTS_COUNT,
@@ -19,11 +18,10 @@ use ::tx::{
     tx_type,
 };
 use core::ops::Eq;
-
-const GTF_INPUT_TYPE = 0x200;
+use ::revert::revert;
 
 // GTF Opcode const selectors
-//
+pub const GTF_INPUT_TYPE = 0x200;
 // pub const GTF_INPUT_COIN_TX_ID = 0x201;
 // pub const GTF_INPUT_COIN_OUTPUT_INDEX = 0x202;
 pub const GTF_INPUT_COIN_OWNER = 0x203;
@@ -34,7 +32,7 @@ pub const GTF_INPUT_COIN_PREDICATE_LENGTH = 0x209;
 pub const GTF_INPUT_COIN_PREDICATE_DATA_LENGTH = 0x20A;
 pub const GTF_INPUT_COIN_PREDICATE = 0x20B;
 pub const GTF_INPUT_COIN_PREDICATE_DATA = 0x20C;
-
+// pub const GTF_INPUT_COIN_PREDICATE_GAS_USED = 0x20D;
 // pub const GTF_INPUT_CONTRACT_CONTRACT_ID = 0x225;
 pub const GTF_INPUT_MESSAGE_SENDER = 0x240;
 pub const GTF_INPUT_MESSAGE_RECIPIENT = 0x241;
@@ -47,6 +45,7 @@ pub const GTF_INPUT_MESSAGE_PREDICATE_DATA_LENGTH = 0x247;
 pub const GTF_INPUT_MESSAGE_DATA = 0x248;
 pub const GTF_INPUT_MESSAGE_PREDICATE = 0x249;
 pub const GTF_INPUT_MESSAGE_PREDICATE_DATA = 0x24A;
+// pub const GTF_INPUT_MESSAGE_PREDICATE_GAS_USED = 0x24B;
 
 /// The input type for a transaction.
 pub enum Input {
@@ -83,7 +82,7 @@ impl Eq for Input {
 ///
 /// # Returns
 ///
-/// * [Input] - The type of the input at `index`.
+/// * [Option<Input>] - The type of the input at `index`.
 ///
 /// # Examples
 ///
@@ -91,16 +90,20 @@ impl Eq for Input {
 /// use std::inputs::input_type;
 ///
 /// fn foo() {
-///     let input_type = input_type(0);
+///     let input_type = input_type(0).unwrap();
 ///     assert(input_type == Input::Coin);
 /// }
 /// ```
-pub fn input_type(index: u64) -> Input {
+pub fn input_type(index: u64) -> Option<Input> {
+    if index >= input_count().as_u64() {
+        return None
+    }
+
     match __gtf::<u8>(index, GTF_INPUT_TYPE) {
-        0u8 => Input::Coin,
-        1u8 => Input::Contract,
-        2u8 => Input::Message,
-        _ => revert(0),
+        0u8 => Some(Input::Coin),
+        1u8 => Some(Input::Contract),
+        2u8 => Some(Input::Message),
+        _ => None,
     }
 }
 
@@ -110,6 +113,10 @@ pub fn input_type(index: u64) -> Input {
 ///
 /// * [u16] - The number of inputs in the transaction.
 ///
+/// # Reverts
+///
+/// * When the input type is unrecognized. This should never happen.
+///
 /// # Examples
 ///
 /// ```sway
@@ -124,6 +131,10 @@ pub fn input_count() -> u16 {
     match tx_type() {
         Transaction::Script => __gtf::<u16>(0, GTF_SCRIPT_INPUTS_COUNT),
         Transaction::Create => __gtf::<u16>(0, GTF_CREATE_INPUTS_COUNT),
+        Transaction::Upgrade => __gtf::<u16>(0, GTF_SCRIPT_INPUTS_COUNT),
+        Transaction::Upload => __gtf::<u16>(0, GTF_SCRIPT_INPUTS_COUNT),
+        Transaction::Blob => __gtf::<u16>(0, GTF_SCRIPT_INPUTS_COUNT),
+        _ => revert(0),
     }
 }
 
@@ -135,7 +146,7 @@ pub fn input_count() -> u16 {
 ///
 /// # Returns
 ///
-/// * [u64] - The pointer of the input at `index`.
+/// * [Option<raw_ptr>] - The pointer of the input at `index`.
 ///
 /// # Examples
 ///
@@ -143,13 +154,22 @@ pub fn input_count() -> u16 {
 /// use std::inputs::input_pointer;
 ///
 /// fn foo() {
-///     let input_pointer = input_pointer(0);
+///     let input_pointer = input_pointer(0).unwrap();
 /// }
 /// ```
-pub fn input_pointer(index: u64) -> u64 {
+#[allow(dead_code)]
+fn input_pointer(index: u64) -> Option<raw_ptr> {
+    if index >= input_count().as_u64() {
+        return None
+    }
+
     match tx_type() {
-        Transaction::Script => __gtf::<u64>(index, GTF_SCRIPT_INPUT_AT_INDEX),
-        Transaction::Create => __gtf::<u64>(index, GTF_CREATE_INPUT_AT_INDEX),
+        Transaction::Script => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_INPUT_AT_INDEX)),
+        Transaction::Create => Some(__gtf::<raw_ptr>(index, GTF_CREATE_INPUT_AT_INDEX)),
+        Transaction::Upgrade => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_INPUT_AT_INDEX)),
+        Transaction::Upload => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_INPUT_AT_INDEX)),
+        Transaction::Blob => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_INPUT_AT_INDEX)),
+        _ => None,
     }
 }
 
@@ -175,9 +195,9 @@ pub fn input_pointer(index: u64) -> u64 {
 /// ```
 pub fn input_amount(index: u64) -> Option<u64> {
     match input_type(index) {
-        Input::Coin => Some(__gtf::<u64>(index, GTF_INPUT_COIN_AMOUNT)),
-        Input::Message => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_AMOUNT)),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(__gtf::<u64>(index, GTF_INPUT_COIN_AMOUNT)),
+        Some(Input::Message) => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_AMOUNT)),
+        _ => None,
     }
 }
 
@@ -203,7 +223,7 @@ pub fn input_amount(index: u64) -> Option<u64> {
 /// ```
 pub fn input_coin_owner(index: u64) -> Option<Address> {
     match input_type(index) {
-        Input::Coin => Some(Address::from(__gtf::<b256>(index, GTF_INPUT_COIN_OWNER))),
+        Some(Input::Coin) => Some(Address::from(__gtf::<b256>(index, GTF_INPUT_COIN_OWNER))),
         _ => None,
     }
 }
@@ -227,11 +247,12 @@ pub fn input_coin_owner(index: u64) -> Option<Address> {
 ///     let input_predicate_data_pointer = input_predicate_data_pointer(0);
 ///     assert(input_predicate_data_pointer.is_some()); // Ensure the input is a coin or message input.
 /// }
-pub fn input_predicate_data_pointer(index: u64) -> Option<raw_ptr> {
+#[allow(dead_code)]
+fn input_predicate_data_pointer(index: u64) -> Option<raw_ptr> {
     match input_type(index) {
-        Input::Coin => Some(__gtf::<raw_ptr>(index, GTF_INPUT_COIN_PREDICATE_DATA)),
-        Input::Message => Some(__gtf::<raw_ptr>(index, GTF_INPUT_MESSAGE_PREDICATE_DATA)),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(__gtf::<raw_ptr>(index, GTF_INPUT_COIN_PREDICATE_DATA)),
+        Some(Input::Message) => Some(__gtf::<raw_ptr>(index, GTF_INPUT_MESSAGE_PREDICATE_DATA)),
+        _ => None,
     }
 }
 
@@ -243,7 +264,7 @@ pub fn input_predicate_data_pointer(index: u64) -> Option<raw_ptr> {
 ///
 /// # Returns
 ///
-/// * [T] - The predicate data of the input at `index`.
+/// * [Option<T>] - The predicate data of the input at `index`.
 ///
 /// # Examples
 ///
@@ -251,16 +272,19 @@ pub fn input_predicate_data_pointer(index: u64) -> Option<raw_ptr> {
 /// use std::inputs::input_predicate_data;
 ///
 /// fn foo() {
-///     let input_predicate_data: u64 = input_predicate_data(0);
+///     let input_predicate_data: u64 = input_predicate_data::<u64>(0).unwrap();
 ///     assert(input_predicate_data == 100);
 /// }
 /// ```
-pub fn input_predicate_data<T>(index: u64) -> T
+pub fn input_predicate_data<T>(index: u64) -> Option<T>
 where
     T: AbiDecode,
 {
-    use core::codec::decode_predicate_data_by_index;
-    decode_predicate_data_by_index::<T>(index)
+    match input_type(index) {
+        Some(Input::Coin) => Some(core::codec::decode_predicate_data_by_index::<T>(index)),
+        Some(Input::Message) => Some(core::codec::decode_predicate_data_by_index::<T>(index)),
+        _ => None,
+    }
 }
 
 /// Gets the AssetId of the input at `index`.
@@ -285,9 +309,9 @@ where
 /// ```
 pub fn input_asset_id(index: u64) -> Option<AssetId> {
     match input_type(index) {
-        Input::Coin => Some(AssetId::from(__gtf::<b256>(index, GTF_INPUT_COIN_ASSET_ID))),
-        Input::Message => Some(AssetId::base()),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(AssetId::from(__gtf::<b256>(index, GTF_INPUT_COIN_ASSET_ID))),
+        Some(Input::Message) => Some(AssetId::base()),
+        _ => None,
     }
 }
 
@@ -313,9 +337,9 @@ pub fn input_asset_id(index: u64) -> Option<AssetId> {
 /// ```
 pub fn input_witness_index(index: u64) -> Option<u16> {
     match input_type(index) {
-        Input::Coin => Some(__gtf::<u16>(index, GTF_INPUT_COIN_WITNESS_INDEX)),
-        Input::Message => Some(__gtf::<u16>(index, GTF_INPUT_MESSAGE_WITNESS_INDEX)),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(__gtf::<u16>(index, GTF_INPUT_COIN_WITNESS_INDEX)),
+        Some(Input::Message) => Some(__gtf::<u16>(index, GTF_INPUT_MESSAGE_WITNESS_INDEX)),
+        _ => None,
     }
 }
 
@@ -341,9 +365,9 @@ pub fn input_witness_index(index: u64) -> Option<u16> {
 /// ```
 pub fn input_predicate_length(index: u64) -> Option<u64> {
     match input_type(index) {
-        Input::Coin => Some(__gtf::<u64>(index, GTF_INPUT_COIN_PREDICATE_LENGTH)),
-        Input::Message => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_PREDICATE_LENGTH)),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(__gtf::<u64>(index, GTF_INPUT_COIN_PREDICATE_LENGTH)),
+        Some(Input::Message) => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_PREDICATE_LENGTH)),
+        _ => None,
     }
 }
 
@@ -367,11 +391,11 @@ pub fn input_predicate_length(index: u64) -> Option<u64> {
 ///     assert(input_predicate_pointer.is_some());
 /// }
 /// ```
-pub fn input_predicate_pointer(index: u64) -> Option<raw_ptr> {
+fn input_predicate_pointer(index: u64) -> Option<raw_ptr> {
     match input_type(index) {
-        Input::Coin => Some(__gtf::<raw_ptr>(index, GTF_INPUT_COIN_PREDICATE)),
-        Input::Message => Some(__gtf::<raw_ptr>(index, GTF_INPUT_MESSAGE_PREDICATE)),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(__gtf::<raw_ptr>(index, GTF_INPUT_COIN_PREDICATE)),
+        Some(Input::Message) => Some(__gtf::<raw_ptr>(index, GTF_INPUT_MESSAGE_PREDICATE)),
+        _ => None,
     }
 }
 
@@ -383,11 +407,7 @@ pub fn input_predicate_pointer(index: u64) -> Option<raw_ptr> {
 ///
 /// # Returns
 ///
-/// * [Bytes] - The predicate bytecode of the input at `index`, if the input's type is `Input::Coin` or `Input::Message`.
-///
-/// # Reverts
-///
-/// * When the input's type is not `Input::Coin` or `Input::Message`.
+/// * [Option<Bytes>] - The predicate bytecode of the input at `index`, if the input's type is `Input::Coin` or `Input::Message`.
 ///
 /// # Examples
 ///
@@ -395,23 +415,24 @@ pub fn input_predicate_pointer(index: u64) -> Option<raw_ptr> {
 /// use std::inputs::input_predicate;
 ///
 /// fn foo() {
-///     let input_predicate = input_predicate(0);
+///     let input_predicate = input_predicate(0).unwrap();
 ///     assert(input_predicate.len() != 0);
 /// }
 /// ```
-pub fn input_predicate(index: u64) -> Bytes {
+pub fn input_predicate(index: u64) -> Option<Bytes> {
     let wrapped = input_predicate_length(index);
     if wrapped.is_none() {
-        revert(0);
-    };
+        return None
+    }
+
     let length = wrapped.unwrap();
-    let new_ptr = alloc_bytes(length);
     match input_predicate_pointer(index) {
         Some(d) => {
+            let new_ptr = alloc_bytes(length);
             d.copy_bytes_to(new_ptr, length);
-            Bytes::from(raw_slice::from_parts::<u8>(new_ptr, length))
+            Some(Bytes::from(raw_slice::from_parts::<u8>(new_ptr, length)))
         },
-        None => revert(0),
+        None => None,
     }
 }
 
@@ -437,14 +458,12 @@ pub fn input_predicate(index: u64) -> Bytes {
 /// ```
 pub fn input_predicate_data_length(index: u64) -> Option<u64> {
     match input_type(index) {
-        Input::Coin => Some(__gtf::<u64>(index, GTF_INPUT_COIN_PREDICATE_DATA_LENGTH)),
-        Input::Message => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_PREDICATE_DATA_LENGTH)),
-        Input::Contract => None,
+        Some(Input::Coin) => Some(__gtf::<u64>(index, GTF_INPUT_COIN_PREDICATE_DATA_LENGTH)),
+        Some(Input::Message) => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_PREDICATE_DATA_LENGTH)),
+        _ => None,
     }
 }
 
-// Coin Inputs
-
 /// Gets the sender of the input message at `index`.
 ///
 /// # Arguments
@@ -453,7 +472,7 @@ pub fn input_predicate_data_length(index: u64) -> Option<u64> {
 ///
 /// # Returns
 ///
-/// * [Address] - The sender of the input message at `index`, if the input's type is `Input::Message`.
+/// * [Option<Address>] - The sender of the input message at `index`, if the input's type is `Input::Message`.
 ///
 /// # Examples
 ///
@@ -461,12 +480,15 @@ pub fn input_predicate_data_length(index: u64) -> Option<u64> {
 /// use std::inputs::input_message_sender;
 ///
 /// fn foo() {
-///     let input_message_sender = input_message_sender(0);
+///     let input_message_sender = input_message_sender(0).unwrap();
 ///     assert(input_message_sender != Address::zero());
 /// }
 /// ```
-pub fn input_message_sender(index: u64) -> Address {
-    Address::from(__gtf::<b256>(index, GTF_INPUT_MESSAGE_SENDER))
+pub fn input_message_sender(index: u64) -> Option<Address> {
+    match input_type(index) {
+        Some(Input::Message) => Some(Address::from(__gtf::<b256>(index, GTF_INPUT_MESSAGE_SENDER))),
+        _ => None,
+    }
 }
 
 /// Gets the recipient of the input message at `index`.
@@ -477,7 +499,7 @@ pub fn input_message_sender(index: u64) -> Address {
 ///
 /// # Returns
 ///
-/// * [Address] - The recipient of the input message at `index`, if the input's type is `Input::Message`.
+/// * [Option<Address>] - The recipient of the input message at `index`, if the input's type is `Input::Message`.
 ///
 /// # Examples
 ///
@@ -485,12 +507,15 @@ pub fn input_message_sender(index: u64) -> Address {
 /// use std::inputs::input_message_recipient;
 ///
 /// fn foo() {
-///     let input_message_recipient = input_message_recipient(0);
+///     let input_message_recipient = input_message_recipient(0).unwrap();
 ///     assert(input_message_recipient != Address::zero());
 /// }
 /// ```
-pub fn input_message_recipient(index: u64) -> Address {
-    Address::from(__gtf::<b256>(index, GTF_INPUT_MESSAGE_RECIPIENT))
+pub fn input_message_recipient(index: u64) -> Option<Address> {
+    match input_type(index) {
+        Some(Input::Message) => Some(Address::from(__gtf::<b256>(index, GTF_INPUT_MESSAGE_RECIPIENT))),
+        _ => None,
+    }
 }
 
 /// Gets the nonce of input message at `index`.
@@ -513,8 +538,11 @@ pub fn input_message_recipient(index: u64) -> Address {
 ///     assert(input_message_nonce != b256::zero());
 /// }
 /// ```
-pub fn input_message_nonce(index: u64) -> b256 {
-    __gtf::<b256>(index, GTF_INPUT_MESSAGE_NONCE)
+pub fn input_message_nonce(index: u64) -> Option<b256> {
+    match input_type(index) {
+        Some(Input::Message) => Some(__gtf::<b256>(index, GTF_INPUT_MESSAGE_NONCE)),
+        _ => None,
+    }
 }
 
 /// Gets the length of the input message at `index`.
@@ -525,7 +553,7 @@ pub fn input_message_nonce(index: u64) -> b256 {
 ///
 /// # Returns
 ///
-/// * [u64] - The length of the input message at `index`, if the input's type is `Input::Message`.
+/// * [Option<u64>] - The length of the input message at `index`, if the input's type is `Input::Message`.
 ///
 /// # Examples
 ///
@@ -533,12 +561,15 @@ pub fn input_message_nonce(index: u64) -> b256 {
 /// use std::inputs::input_message_length;
 ///
 /// fn foo() {
-///     let input_message_length = input_message_length(0);
+///     let input_message_length = input_message_length(0).unwrap();
 ///     assert(input_message_length != 0_u64);
 /// }
 /// ```
-pub fn input_message_data_length(index: u64) -> u64 {
-    __gtf::<u64>(index, GTF_INPUT_MESSAGE_DATA_LENGTH)
+pub fn input_message_data_length(index: u64) -> Option<u64> {
+    match input_type(index) {
+        Some(Input::Message) => Some(__gtf::<u64>(index, GTF_INPUT_MESSAGE_DATA_LENGTH)),
+        _ => None,
+    }
 }
 
 /// Gets the data of the input message at `index`.
@@ -550,11 +581,7 @@ pub fn input_message_data_length(index: u64) -> u64 {
 ///
 /// # Returns
 ///
-/// * [Bytes] - The data of the input message at `index`, if the input's type is `Input::Message`.
-///
-/// # Reverts
-///
-/// * When the input's type is not `Input::Message`.
+/// * [Option<Bytes>] - The data of the input message at `index`, if the input's type is `Input::Message`.
 ///
 /// # Examples
 ///
@@ -562,21 +589,26 @@ pub fn input_message_data_length(index: u64) -> u64 {
 /// use std::inputs::input_message_data;
 ///
 /// fn foo() {
-///     let input_message_data = input_message_data(0, 0);
+///     let input_message_data = input_message_data(0, 0).unwrap();
 ///     assert(input_message_data.len() != 0);
 /// }
 /// ```
-pub fn input_message_data(index: u64, offset: u64) -> Bytes {
-    assert(valid_input_type(index, Input::Message));
-    let data = __gtf::<raw_ptr>(index, GTF_INPUT_MESSAGE_DATA);
-    let data_with_offset = data.add_uint_offset(offset);
-    let length = input_message_data_length(index);
-    let new_ptr = alloc_bytes(length);
+pub fn input_message_data(index: u64, offset: u64) -> Option<Bytes> {
+    match input_type(index) {
+        Some(Input::Message) => {
+            let data = __gtf::<raw_ptr>(index, GTF_INPUT_MESSAGE_DATA);
+            let data_with_offset = data.add_uint_offset(offset);
+            let total_length = input_message_data_length(index).unwrap();
+            if offset > total_length {
+                return None
+            }
+            let offset_length = total_length - offset;
 
-    data_with_offset.copy_bytes_to(new_ptr, length);
-    Bytes::from(raw_slice::from_parts::<u8>(new_ptr, length))
-}
+            let new_ptr = alloc_bytes(offset_length);
 
-fn valid_input_type(index: u64, expected_type: Input) -> bool {
-    input_type(index) == expected_type
+            data_with_offset.copy_bytes_to(new_ptr, offset_length);
+            Some(Bytes::from(raw_slice::from_parts::<u8>(new_ptr, offset_length)))
+        },
+        _ => None,
+    }
 }
diff --git a/sway-lib-std/src/lib.sw b/sway-lib-std/src/lib.sw
index cfa77928d0a..fc09e123cd6 100644
--- a/sway-lib-std/src/lib.sw
+++ b/sway-lib-std/src/lib.sw
@@ -14,8 +14,8 @@ pub mod registers;
 pub mod iterator;
 pub mod vec;
 pub mod bytes;
-pub mod math;
 pub mod flags;
+pub mod math;
 pub mod u128;
 pub mod b512;
 pub mod primitive_conversions;
@@ -45,5 +45,3 @@ pub mod low_level_call;
 pub mod array_conversions;
 pub mod bytes_conversions;
 pub mod clone;
-
-use core::*;
diff --git a/sway-lib-std/src/math.sw b/sway-lib-std/src/math.sw
index 2b729cadbfc..6ffd4071865 100644
--- a/sway-lib-std/src/math.sw
+++ b/sway-lib-std/src/math.sw
@@ -1,6 +1,17 @@
 //! Utilities for common math operations.
 library;
 
+use ::assert::*;
+use ::revert::revert;
+use ::option::Option::{self, None, Some};
+use ::flags::{
+    disable_panic_on_overflow,
+    panic_on_overflow_enabled,
+    panic_on_unsafe_math_enabled,
+    set_flags,
+};
+use ::registers::{flags, overflow};
+
 /// Calculates the square root.
 pub trait Root {
     fn sqrt(self) -> Self;
@@ -69,12 +80,38 @@ pub trait Power {
     fn pow(self, exponent: u32) -> Self;
 }
 
+fn u256_checked_mul(a: u256, b: u256) -> Option<u256> {
+    let res = u256::zero();
+
+    // The six-bit immediate value is used to select operating mode, as follows:
+
+    // Bits	Short name	Description
+    // ..XXXX	reserved	Reserved and must be zero
+    // .X....	indirect0	Is lhs operand ($rB) indirect or not
+    // X.....	indirect1	Is rhs operand ($rC) indirect or not
+    // As both operands are indirect, 110000 is used, which is 48 in decimal.
+    let of = asm(res: res, a: a, b: b) {
+        wqml res a b i48;
+        of: u64
+    };
+
+    if of != 0 {
+        return None;
+    }
+
+    Some(res)
+}
+
 impl Power for u256 {
     /// Raises self to the power of `exponent`, using exponentiation by squaring.
     ///
-    /// # Panics
+    /// # Additional Information
+    ///
+    /// * If panic on overflow is disabled, and the result overflows, the return value will be 0.
+    ///
+    /// # Reverts
     ///
-    /// Panics if the result overflows the type.
+    /// * Reverts if the result overflows the type, if panic on overflow is enabled.
     fn pow(self, exponent: u32) -> Self {
         let one = 0x0000000000000000000000000000000000000000000000000000000000000001u256;
 
@@ -88,13 +125,28 @@ impl Power for u256 {
 
         while exp > 1 {
             if (exp & 1) == 1 {
-                acc = acc * base;
+                // acc = acc * base;
+                let res = u256_checked_mul(acc, base);
+                acc = match res {
+                    Some(val) => val,
+                    None => return u256::zero(),
+                }
             }
             exp = exp >> 1;
-            base = base * base;
+            // base = base * base;
+            let res = u256_checked_mul(base, base);
+            base = match res {
+                Some(val) => val,
+                None => return u256::zero(),
+            }
         }
 
-        acc * base
+        // acc * base
+        let res = u256_checked_mul(acc, base);
+        match res {
+            Some(val) => val,
+            None => u256::zero(),
+        }
     }
 }
 
@@ -109,27 +161,69 @@ impl Power for u64 {
 
 impl Power for u32 {
     fn pow(self, exponent: u32) -> Self {
-        asm(r1: self, r2: exponent, r3) {
+        let mut res = asm(r1: self, r2: exponent, r3) {
             exp r3 r1 r2;
-            r3: Self
+            r3: u64
+        };
+
+        if res > Self::max().as_u64() {
+            // If panic on wrapping math is enabled, only then revert
+            if panic_on_overflow_enabled() {
+                revert(0);
+            } else {
+                // Follow spec of returning 0 for overflow
+                res = 0;
+            }
+        }
+
+        asm(r1: res) {
+            r1: Self
         }
     }
 }
 
 impl Power for u16 {
     fn pow(self, exponent: u32) -> Self {
-        asm(r1: self, r2: exponent, r3) {
+        let mut res = asm(r1: self, r2: exponent, r3) {
             exp r3 r1 r2;
-            r3: Self
+            r3: u64
+        };
+
+        if res > Self::max().as_u64() {
+            // If panic on wrapping math is enabled, only then revert
+            if panic_on_overflow_enabled() {
+                revert(0);
+            } else {
+                // Follow spec of returning 0 for overflow
+                res = 0;
+            }
+        }
+
+        asm(r1: res) {
+            r1: Self
         }
     }
 }
 
 impl Power for u8 {
     fn pow(self, exponent: u32) -> Self {
-        asm(r1: self, r2: exponent, r3) {
+        let mut res = asm(r1: self, r2: exponent, r3) {
             exp r3 r1 r2;
-            r3: Self
+            r3: u64
+        };
+
+        if res > Self::max().as_u64() {
+            // If panic on wrapping math is enabled, only then revert
+            if panic_on_overflow_enabled() {
+                revert(0);
+            } else {
+                // Follow spec of returning 0 for overflow
+                res = 0;
+            }
+        }
+
+        asm(r1: res) {
+            r1: Self
         }
     }
 }
@@ -213,8 +307,12 @@ impl BinaryLogarithm for u8 {
 
 impl BinaryLogarithm for u256 {
     fn log2(self) -> Self {
-        use ::assert::*;
-        assert(self != 0);
+        // If panic on unsafe math is enabled, only then revert
+        if panic_on_unsafe_math_enabled() {
+            // Logarithm is undefined for 0
+            assert(self != 0);
+        }
+
         let (a, b, c, d) = asm(r1: self) {
             r1: (u64, u64, u64, u64)
         };
@@ -233,9 +331,66 @@ impl BinaryLogarithm for u256 {
 
 impl Logarithm for u256 {
     fn log(self, base: Self) -> Self {
+        let flags = disable_panic_on_overflow();
+
+        // If panic on unsafe math is enabled, only then revert
+        if panic_on_unsafe_math_enabled() {
+            // Logarithm is undefined for bases less than 2
+            assert(base >= 2);
+            // Logarithm is undefined for 0
+            assert(self != 0);
+        } else {
+            // Logarithm is undefined for bases less than 2
+            // Logarithm is undefined for 0
+            if (base < 2) || (self == 0) {
+                set_flags(flags);
+                return 0x00u256;
+            }
+        }
+
+        // Decimals rounded to 0
+        if self < base {
+            set_flags(flags);
+            return 0x00u256;
+        }
+
+        // Estimating the result using change of base formula. Only an estimate because we are doing uint calculations.
         let self_log2 = self.log2();
         let base_log2 = base.log2();
-        self_log2 / base_log2
+        let mut result = (self_log2 / base_log2);
+
+        // Converting u256 to u32, this cannot fail as the result will be atmost ~256
+        let parts = asm(r1: result) {
+            r1: (u64, u64, u64, u64)
+        };
+        let res_u32 = asm(r1: parts.3) {
+            r1: u32
+        };
+
+        // Raising the base to the power of the result
+        let mut pow_res = base.pow(res_u32);
+        let mut of = overflow();
+
+        // Adjusting the result until the power is less than or equal to self
+        // If pow_res is > than self, then there is an overestimation. If there is an overflow then there is definitely an overestimation.
+        while (pow_res > self) || (of > 0) {
+            result -= 1;
+
+            // Converting u256 to u32, this cannot fail as the result will be atmost ~256
+            let parts = asm(r1: result) {
+                r1: (u64, u64, u64, u64)
+            };
+            let res_u32 = asm(r1: parts.3) {
+                r1: u32
+            };
+
+            pow_res = base.pow(res_u32);
+            of = overflow();
+        };
+
+        set_flags(flags);
+
+        result
     }
 }
 
diff --git a/sway-lib-std/src/outputs.sw b/sway-lib-std/src/outputs.sw
index 7524ad31935..69ccac1b23b 100644
--- a/sway-lib-std/src/outputs.sw
+++ b/sway-lib-std/src/outputs.sw
@@ -38,6 +38,8 @@ pub enum Output {
     Change: (),
     /// A variable output.
     Variable: (),
+    /// A contract deployment.
+    ContractCreated: (),
 }
 
 /// Get the type of an output at `index`.
@@ -48,11 +50,7 @@ pub enum Output {
 ///
 /// # Returns
 ///
-/// * [Output] - The type of the output at `index`.
-///
-/// # Reverts
-///
-/// * When the output type is unrecognized. This should never happen.
+/// * [Option<Output>] - The type of the output at `index`.
 ///
 /// # Examples
 ///
@@ -60,22 +58,28 @@ pub enum Output {
 /// use std::outputs::output_type;
 ///
 /// fn foo() {
-///     let output_type = output_type(0);
+///     let output_type = output_type(0).unwrap();
 ///     match output_type {
 ///         Output::Coin => { log("The output is a coin") },
 ///         Output::Contract => { log("The output is a contract") },
 ///         Output::Change => { log("The output is change") },
 ///         Output::Variable => { log("The output is a variable") },
+///         Output::ContractCreated => { log("The output is a contract creation") },
 ///     };
 /// }
 /// ```
-pub fn output_type(index: u64) -> Output {
+pub fn output_type(index: u64) -> Option<Output> {
+    if index >= output_count().as_u64() {
+        return None
+    }
+
     match __gtf::<u8>(index, GTF_OUTPUT_TYPE) {
-        0u8 => Output::Coin,
-        1u8 => Output::Contract,
-        2u8 => Output::Change,
-        3u8 => Output::Variable,
-        _ => revert(0),
+        0u8 => Some(Output::Coin),
+        1u8 => Some(Output::Contract),
+        2u8 => Some(Output::Change),
+        3u8 => Some(Output::Variable),
+        4u8 => Some(Output::ContractCreated),
+        _ => None,
     }
 }
 
@@ -88,11 +92,7 @@ pub fn output_type(index: u64) -> Output {
 ///
 /// # Returns
 ///
-/// * [u64] - A pointer to the output at `index`.
-///
-/// # Reverts
-///
-/// * When the output type is unrecognized. This should never happen.
+/// * [Option<raw_ptr>] - A pointer to the output at `index`.
 ///
 /// # Examples
 ///
@@ -100,14 +100,21 @@ pub fn output_type(index: u64) -> Output {
 /// use std::outputs::output_pointer;
 ///
 /// fn foo() {
-///     let output_pointer = output_pointer(0);
-///     log(output_pointer);
+///     let output_pointer = output_pointer(0).unwrap();
 /// }
 /// ```
-pub fn output_pointer(index: u64) -> u64 {
+fn output_pointer(index: u64) -> Option<raw_ptr> {
+    if output_type(index).is_none() {
+        return None
+    }
+
     match tx_type() {
-        Transaction::Script => __gtf::<u64>(index, GTF_SCRIPT_OUTPUT_AT_INDEX),
-        Transaction::Create => __gtf::<u64>(index, GTF_CREATE_OUTPUT_AT_INDEX),
+        Transaction::Script => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_OUTPUT_AT_INDEX)),
+        Transaction::Create => Some(__gtf::<raw_ptr>(index, GTF_CREATE_OUTPUT_AT_INDEX)),
+        Transaction::Upgrade => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_OUTPUT_AT_INDEX)),
+        Transaction::Upload => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_OUTPUT_AT_INDEX)),
+        Transaction::Blob => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_OUTPUT_AT_INDEX)),
+        _ => None,
     }
 }
 
@@ -116,7 +123,7 @@ pub fn output_pointer(index: u64) -> u64 {
 ///
 /// # Returns
 ///
-/// * [u64] - The transaction outputs count.
+/// * [u16] - The transaction outputs count.
 ///
 /// # Reverts
 ///
@@ -132,10 +139,14 @@ pub fn output_pointer(index: u64) -> u64 {
 ///     log(output_count);
 /// }
 /// ```
-pub fn output_count() -> u64 {
+pub fn output_count() -> u16 {
     match tx_type() {
-        Transaction::Script => __gtf::<u64>(0, GTF_SCRIPT_OUTPUTS_COUNT),
-        Transaction::Create => __gtf::<u64>(0, GTF_CREATE_OUTPUTS_COUNT),
+        Transaction::Script => __gtf::<u16>(0, GTF_SCRIPT_OUTPUTS_COUNT),
+        Transaction::Create => __gtf::<u16>(0, GTF_CREATE_OUTPUTS_COUNT),
+        Transaction::Upgrade => __gtf::<u16>(0, GTF_SCRIPT_OUTPUTS_COUNT),
+        Transaction::Upload => __gtf::<u16>(0, GTF_SCRIPT_OUTPUTS_COUNT),
+        Transaction::Blob => __gtf::<u16>(0, GTF_SCRIPT_OUTPUTS_COUNT),
+        _ => revert(0),
     }
 }
 
@@ -155,12 +166,7 @@ pub fn output_count() -> u64 {
 ///
 /// # Returns
 ///
-/// * [u64] - The amount of coins to send to the output at `index`.
-///
-/// # Reverts
-///
-/// * When the output type is `Output::Contract`.
-/// * When the output type is unrecognized. This should never happen.
+/// * [Option<u64>] - The amount of coins to send to the output at `index`.
 ///
 /// # Examples
 ///
@@ -172,31 +178,29 @@ pub fn output_count() -> u64 {
 ///     log(output_amount);
 /// }
 /// ```
-pub fn output_amount(index: u64) -> u64 {
+pub fn output_amount(index: u64) -> Option<u64> {
     match output_type(index) {
-        Output::Coin => __gtf::<u64>(index, GTF_OUTPUT_COIN_AMOUNT),
-        Output::Contract => revert(0),
+        Some(Output::Coin) => Some(__gtf::<u64>(index, GTF_OUTPUT_COIN_AMOUNT)),
+        Some(Output::Contract) => None,
         // For now, output changes are always guaranteed to have an amount of
         // zero since they're only set after execution terminates.
-        // use `__gtf` when GTF_OUTPUT_CHANGE_AMOUNT is available.
-        // See https://github.com/FuelLabs/fuel-specs/issues/402
-        // and https://github.com/FuelLabs/sway/issues/2671.
-        Output::Change => 0,
-        // use `__gtf` when GTF_OUTPUT_VARIABLE_AMOUNT is available.
-        // See https://github.com/FuelLabs/fuel-specs/issues/402
-        // and https://github.com/FuelLabs/sway/issues/2671.
-        Output::Variable => {
-            let ptr = output_pointer(index);
-            asm(r1, r2, r3: ptr) {
-                addi r2 r3 i40;
-                lw r1 r2 i0;
-                r1: u64
-            }
+        Some(Output::Change) => Some(0),
+        Some(Output::Variable) => {
+            let ptr = output_pointer(index).unwrap();
+            Some(
+                asm(r1, r2, r3: ptr) {
+                    addi r2 r3 i40;
+                    lw r1 r2 i0;
+                    r1: u64
+                },
+            )
         },
+        Some(Output::ContractCreated) => None,
+        None => None,
     }
 }
 
-/// Gets the AssetId of the output if it is a `Output::Coin`.
+/// Gets the AssetId of the output.
 ///
 /// # Arguments
 ///
@@ -204,7 +208,7 @@ pub fn output_amount(index: u64) -> u64 {
 ///
 /// # Returns
 ///
-/// * [Option<AssetId>] - The AssetId of the output if it is a `Output::Coin`. None otherwise.
+/// * [Option<AssetId>] - The AssetId of the output. None otherwise.
 ///
 /// # Reverts
 ///
@@ -222,12 +226,13 @@ pub fn output_amount(index: u64) -> u64 {
 /// ```
 pub fn output_asset_id(index: u64) -> Option<AssetId> {
     match output_type(index) {
-        Output::Coin => Some(AssetId::from(__gtf::<b256>(index, GTF_OUTPUT_COIN_ASSET_ID))),
+        Some(Output::Coin) => Some(AssetId::from(__gtf::<b256>(index, GTF_OUTPUT_COIN_ASSET_ID))),
+        Some(Output::Change) => Some(AssetId::from(__gtf::<b256>(index, GTF_OUTPUT_COIN_ASSET_ID))),
         _ => None,
     }
 }
 
-/// Returns the receiver of the output if it is a `Output::Coin`.
+/// Returns the receiver of the output.
 ///
 /// # Arguments
 ///
@@ -235,7 +240,7 @@ pub fn output_asset_id(index: u64) -> Option<AssetId> {
 ///
 /// # Returns
 ///
-/// * [Option<Address>] - The receiver of the output if it is a `Output::Coin`. None otherwise.
+/// * [Option<Address>] - The receiver of the output. None otherwise.
 ///
 /// # Reverts
 ///
@@ -253,7 +258,21 @@ pub fn output_asset_id(index: u64) -> Option<AssetId> {
 /// ```
 pub fn output_asset_to(index: u64) -> Option<Address> {
     match output_type(index) {
-        Output::Coin => Some(__gtf::<Address>(index, GTF_OUTPUT_COIN_TO)),
+        Some(Output::Coin) => Some(__gtf::<Address>(index, GTF_OUTPUT_COIN_TO)),
+        Some(Output::Change) => Some(__gtf::<Address>(index, GTF_OUTPUT_COIN_TO)),
         _ => None,
     }
 }
+
+impl core::ops::Eq for Output {
+    fn eq(self, other: Self) -> bool {
+        match (self, other) {
+            (Output::Coin, Output::Coin) => true,
+            (Output::Contract, Output::Contract) => true,
+            (Output::Change, Output::Change) => true,
+            (Output::Variable, Output::Variable) => true,
+            (Output::ContractCreated, Output::ContractCreated) => true,
+            _ => false,
+        }
+    }
+}
diff --git a/sway-lib-std/src/prelude.sw b/sway-lib-std/src/prelude.sw
index 73fc1ae6e5d..6f207cc7b45 100644
--- a/sway-lib-std/src/prelude.sw
+++ b/sway-lib-std/src/prelude.sw
@@ -4,36 +4,36 @@
 library;
 
 // Blockchain types
-use ::address::Address;
-use ::alias::SubId;
-use ::asset_id::AssetId;
-use ::contract_id::ContractId;
-use ::identity::Identity;
+pub use ::address::Address;
+pub use ::alias::SubId;
+pub use ::asset_id::AssetId;
+pub use ::contract_id::ContractId;
+pub use ::identity::Identity;
 
 // `StorageKey` API
-use ::storage::storage_key::*;
+pub use ::storage::storage_key::*;
 
 // Collections
-use ::storage::storage_map::*;
-use ::vec::{Vec, VecIter};
+pub use ::storage::storage_map::*;
+pub use ::vec::{Vec, VecIter};
 
 // Error handling
-use ::assert::{assert, assert_eq, assert_ne};
-use ::option::Option::{self, *};
-use ::result::Result::{self, *};
-use ::revert::{require, revert};
+pub use ::assert::{assert, assert_eq, assert_ne};
+pub use ::option::Option::{self, *};
+pub use ::result::Result::{self, *};
+pub use ::revert::{require, revert};
 
 // Convert
-use ::convert::From;
+pub use ::convert::From;
 
 // Primitive conversions
-use ::primitive_conversions::{b256::*, str::*, u16::*, u256::*, u32::*, u64::*, u8::*,};
+pub use ::primitive_conversions::{b256::*, str::*, u16::*, u256::*, u32::*, u64::*, u8::*,};
 
 // Logging
-use ::logging::log;
+pub use ::logging::log;
 
 // Auth
-use ::auth::msg_sender;
+pub use ::auth::msg_sender;
 
 // Math
-use ::math::*;
+pub use ::math::*;
diff --git a/sway-lib-std/src/primitive_conversions/str.sw b/sway-lib-std/src/primitive_conversions/str.sw
index 27f75b41d92..4ace1dd03a6 100644
--- a/sway-lib-std/src/primitive_conversions/str.sw
+++ b/sway-lib-std/src/primitive_conversions/str.sw
@@ -3,6 +3,20 @@ library;
 use ::option::Option::{self, *};
 
 impl str {
+    /// Attempts to convert the string slice into a string array.
+    ///
+    /// # Returns
+    ///
+    /// * [Option<S>] - `Some(str_array)` if the lengths of the `S` str_array type and the string slice's lengths match. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let string_slice = "abcd";
+    ///     let string_array: str[4] = a.try_as_str_array().unwrap();
+    /// }
+    /// ```
     pub fn try_as_str_array<S>(self) -> Option<S> {
         __assert_is_str_array::<S>();
         let str_size = __size_of_str_array::<S>();
diff --git a/sway-lib-std/src/primitive_conversions/u16.sw b/sway-lib-std/src/primitive_conversions/u16.sw
index bced8a770a5..5a032306332 100644
--- a/sway-lib-std/src/primitive_conversions/u16.sw
+++ b/sway-lib-std/src/primitive_conversions/u16.sw
@@ -5,6 +5,28 @@ use ::option::Option::{self, *};
 use ::u128::U128;
 
 impl u16 {
+    /// Attempts to convert the u16 value into a u8 value.
+    ///
+    /// # Additional Information
+    ///
+    /// The max value a u8 can represent is 255.
+    ///
+    /// # Returns
+    ///
+    /// [Option<u8>] - `Some(u8)` if the u16 is less than or equal to the max u8 value. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let val = 255_u16.try_as_u8();
+    ///     assert(val == Some(255_u8));
+    ///
+    ///     // Conversion fails as value is above the max a u8 can represent.
+    ///     let val2 = 256_u16.try_as_u8();
+    ///     assert(val == None);
+    /// }
+    /// ```
     pub fn try_as_u8(self) -> Option<u8> {
         if self <= u8::max().as_u16() {
             Some(asm(input: self) {
diff --git a/sway-lib-std/src/primitive_conversions/u32.sw b/sway-lib-std/src/primitive_conversions/u32.sw
index ca5a0722680..8ffa2ca2605 100644
--- a/sway-lib-std/src/primitive_conversions/u32.sw
+++ b/sway-lib-std/src/primitive_conversions/u32.sw
@@ -5,6 +5,28 @@ use ::option::Option::{self, *};
 use ::u128::U128;
 
 impl u32 {
+    /// Attempts to convert the u32 value into a u8 value.
+    ///
+    /// # Additional Information
+    ///
+    /// The max value a u8 can represent is 255.
+    ///
+    /// # Returns
+    ///
+    /// [Option<u8>] - `Some(u8)` if the u32 is less than or equal to the max u8 value. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let val = 255_u32.try_as_u8();
+    ///     assert(val == Some(255_u8));
+    ///
+    ///     // Conversion fails as value is above the max a u8 can represent.
+    ///     let val2 = 256_u32.try_as_u8();
+    ///     assert(val == None);
+    /// }
+    /// ```
     pub fn try_as_u8(self) -> Option<u8> {
         if self <= u8::max().as_u32() {
             Some(asm(input: self) {
@@ -15,6 +37,28 @@ impl u32 {
         }
     }
 
+    /// Attempts to convert the u32 value into a u16 value.
+    ///
+    /// # Additional Information
+    ///
+    /// The max value a u16 can represent is 65_535.
+    ///
+    /// # Returns
+    ///
+    /// [Option<u16>] - `Some(u16)` if the u32 is less than or equal to the max u16 value. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let val = 65_535_u32.try_as_u16();
+    ///     assert(val == Some(65_535_u16));
+    ///
+    ///     // Conversion fails as value is above the max a u16 can represent.
+    ///     let val2 = 65_536_u32.try_as_u16();
+    ///     assert(val == None);
+    /// }
+    /// ```
     pub fn try_as_u16(self) -> Option<u16> {
         if self <= u16::max().as_u32() {
             Some(asm(input: self) {
diff --git a/sway-lib-std/src/primitive_conversions/u64.sw b/sway-lib-std/src/primitive_conversions/u64.sw
index b373bb85ae9..92267638a1d 100644
--- a/sway-lib-std/src/primitive_conversions/u64.sw
+++ b/sway-lib-std/src/primitive_conversions/u64.sw
@@ -5,6 +5,28 @@ use ::option::Option::{self, *};
 use ::u128::U128;
 
 impl u64 {
+    /// Attempts to convert the u64 value into a u8 value.
+    ///
+    /// # Additional Information
+    ///
+    /// The max value a u8 can represent is 255.
+    ///
+    /// # Returns
+    ///
+    /// [Option<u8>] - `Some(u8)` if the u64 is less than or equal to the max u8 value. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let val = 255_u64.try_as_u8();
+    ///     assert(val == Some(255_u8));
+    ///
+    ///     // Conversion fails as value is above the max a u8 can represent.
+    ///     let val2 = 256_u64.try_as_u8();
+    ///     assert(val == None);
+    /// }
+    /// ```
     pub fn try_as_u8(self) -> Option<u8> {
         if self <= u8::max().as_u64() {
             Some(asm(input: self) {
@@ -15,6 +37,28 @@ impl u64 {
         }
     }
 
+    /// Attempts to convert the u64 value into a u16 value.
+    ///
+    /// # Additional Information
+    ///
+    /// The max value a u16 can represent is 65_535.
+    ///
+    /// # Returns
+    ///
+    /// [Option<u16>] - `Some(u16)` if the u64 is less than or equal to the max u16 value. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let val = 65_535_u64.try_as_u16();
+    ///     assert(val == Some(65_535_u16));
+    ///
+    ///     // Conversion fails as value is above the max a u16 can represent.
+    ///     let val2 = 65_536_u64.try_as_u16();
+    ///     assert(val == None);
+    /// }
+    /// ```
     pub fn try_as_u16(self) -> Option<u16> {
         if self <= u16::max().as_u64() {
             Some(asm(input: self) {
@@ -25,6 +69,28 @@ impl u64 {
         }
     }
 
+    /// Attempts to convert the u64 value into a u32 value.
+    ///
+    /// # Additional Information
+    ///
+    /// The max value a u32 can represent is 4_294_967_295.
+    ///
+    /// # Returns
+    ///
+    /// [Option<u32>] - `Some(u32)` if the u64 is less than or equal to the max u32 value. Else `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let val = 4_294_967_295_u64.try_as_u32();
+    ///     assert(val == Some(4_294_967_295_u32));
+    ///
+    ///     // Conversion fails as value is above the max a u32 can represent.
+    ///     let val2 = 4_294_967_296_u64.try_as_u32();
+    ///     assert(val == None);
+    /// }
+    /// ```
     pub fn try_as_u32(self) -> Option<u32> {
         if self <= u32::max().as_u64() {
             Some(asm(input: self) {
diff --git a/sway-lib-std/src/result.sw b/sway-lib-std/src/result.sw
index f4f5f79a2b0..9b0532ee567 100644
--- a/sway-lib-std/src/result.sw
+++ b/sway-lib-std/src/result.sw
@@ -269,3 +269,17 @@ impl<T, E> Result<T, E> {
     // - `ok(self) -> Option<T>`
     // - `err(self) -> Option<E>`
 }
+
+impl<T, E> Eq for Result<T, E>
+where
+    T: Eq,
+    E: Eq,
+{
+    fn eq(self, other: Self) -> bool {
+        match (self, other) {
+            (Self::Ok(a), Self::Ok(b)) => a == b,
+            (Self::Err(a), Self::Err(b)) => a == b,
+            _ => false,
+        }
+    }
+}
diff --git a/sway-lib-std/src/storage/storage_key.sw b/sway-lib-std/src/storage/storage_key.sw
index 5f8fc699729..243c839656b 100644
--- a/sway-lib-std/src/storage/storage_key.sw
+++ b/sway-lib-std/src/storage/storage_key.sw
@@ -152,46 +152,3 @@ impl<T> StorageKey<T> {
         self.slot() == b256::zero() && self.field_id() == b256::zero() && self.offset() == 0
     }
 }
-
-#[test]
-fn test_storage_key_new() {
-    use ::assert::assert;
-
-    let key = StorageKey::<u64>::new(b256::zero(), 0, b256::zero());
-    assert(key.slot() == b256::zero());
-    assert(key.offset() == 0);
-    assert(key.field_id() == b256::zero());
-
-    let key = StorageKey::<u64>::new(
-        0x0000000000000000000000000000000000000000000000000000000000000001,
-        1,
-        0x0000000000000000000000000000000000000000000000000000000000000001,
-    );
-    assert(
-        key
-            .slot() == 0x0000000000000000000000000000000000000000000000000000000000000001,
-    );
-    assert(key.offset() == 1);
-    assert(
-        key
-            .field_id() == 0x0000000000000000000000000000000000000000000000000000000000000001,
-    );
-}
-
-#[test]
-fn test_storage_key_zero() {
-    use ::assert::assert;
-
-    let key = StorageKey::<u64>::zero();
-    assert(key.is_zero());
-    assert(key.slot() == b256::zero());
-    assert(key.offset() == 0);
-    assert(key.field_id() == b256::zero());
-
-    let key = StorageKey::<u64>::new(
-        0x0000000000000000000000000000000000000000000000000000000000000001,
-        1,
-        0x0000000000000000000000000000000000000000000000000000000000000001,
-    );
-    assert(!key.is_zero());
-}
diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 540402bc776..6e2dffb3d57 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -809,7 +809,29 @@ impl<V> StorageKey<StorageVec<V>> {
     /// ```
     #[storage(write)]
     pub fn store_vec(self, vec: Vec<V>) {
-        let slice = vec.as_raw_slice();
+        let size_V_bytes = __size_of::<V>();
+
+        // Handle cases where elements are less than the size of word and pad to the size of a word
+        let slice = if size_V_bytes < 8 {
+            let vec_slice = vec.as_raw_slice();
+            let number_of_words = 8 * vec.len();
+            let ptr = alloc_bytes(number_of_words);
+            let mut i = 0;
+            while i < vec.len() {
+                // Insert into raw slice as offsets of 1 word per element
+                // (size_of_word * element)
+                vec_slice
+                    .ptr()
+                    .add::<V>(i)
+                    .copy_bytes_to(ptr.add_uint_offset(8 * i), size_V_bytes);
+                i += 1;
+            }
+
+            raw_slice::from_parts::<V>(ptr, number_of_words)
+        } else {
+            vec.as_raw_slice()
+        };
+
         // Get the number of storage slots needed based on the size of bytes.
         let number_of_bytes = slice.number_of_bytes();
         let number_of_slots = (number_of_bytes + 31) >> 5;
@@ -824,15 +846,23 @@ impl<V> StorageKey<StorageVec<V>> {
 
         // Store the length, NOT the bytes. 
         // This differs from the existing `write_slice()` function to be compatible with `StorageVec`.
-        write::<u64>(self.field_id(), 0, number_of_bytes / __size_of::<V>());
+        write::<u64>(self.field_id(), 0, vec.len());
     }
 
     /// Load a `Vec` from the `StorageVec`.
     ///
+    /// # Additional Information
+    ///
+    /// This method does not work for any `V` type that has a 0 size, such as `StorageVec` itself. Meaning you cannot use this method on a `StorageVec<StorageVec<T>>`.
+    ///
     /// # Returns
     ///
     /// * [Option<Vec<V>>] - The vector constructed from storage or `None`.
     ///
+    /// # Reverts
+    ///
+    /// * If the size of type `V` is 0.
+    ///
     /// # Number of Storage Accesses
     ///
     /// * Reads - `2`
@@ -865,14 +895,47 @@ impl<V> StorageKey<StorageVec<V>> {
             0 => Vec::new(),
             len => {
                 // Get the number of storage slots needed based on the size.
-                let bytes = len * __size_of::<V>();
+                let size_V_bytes = __size_of::<V>();
+
+                assert(size_V_bytes != 0);
+
+                let bytes = if size_V_bytes < 8 {
+                    // Len * size_of_word
+                    len * 8
+                } else {
+                    len * size_V_bytes
+                };
+
                 let number_of_slots = (bytes + 31) >> 5;
                 let ptr = alloc_bytes(number_of_slots * 32);
                 // Load the stored slice into the pointer.
                 let _ = __state_load_quad(sha256(self.field_id()), ptr, number_of_slots);
-                Vec::from(asm(ptr: (ptr, bytes)) {
-                    ptr: raw_slice
-                })
+
+                if size_V_bytes < 8 {
+                    let len_bytes = len * size_V_bytes;
+                    let new_vec = alloc_bytes(len_bytes);
+                    let mut i = 0;
+                    while i < len {
+                        // The stored vec is offset with 1 word per element, remove the padding for elements less than the size of a word
+                        // (size_of_word * element)
+                        ptr
+                            .add_uint_offset((8 * i))
+                            .copy_bytes_to(new_vec.add::<V>(i), size_V_bytes);
+                        i += 1;
+                    }
+
+                    Vec::from(
+                        asm(ptr: (new_vec, len_bytes)) {
+                            ptr: raw_slice
+                        },
+                    )
+                } else {
+                    Vec::from(
+                        asm(ptr: (ptr, bytes)) {
+                            ptr: raw_slice
+                        },
+                    )
+                }
             }
         }
     }
diff --git a/sway-lib-std/src/string.sw b/sway-lib-std/src/string.sw
index 97b6cf76df3..abe9673dbdc 100644
--- a/sway-lib-std/src/string.sw
+++ b/sway-lib-std/src/string.sw
@@ -7,7 +7,7 @@ use ::convert::*;
 use ::hash::{Hash, Hasher};
 use ::option::Option;
 
-/// A UTF-8 encoded growable string.
+/// A UTF-8 encoded growable string. It has ownership over its buffer.
 ///
 /// # Additional Information
 ///
@@ -40,7 +40,7 @@ impl String {
     /// }
     /// ```
     pub fn as_bytes(self) -> Bytes {
-        self.bytes
+        self.bytes.clone()
     }
 
     /// Gets the amount of memory on the heap allocated to the `String`.
@@ -113,7 +113,9 @@ impl String {
     /// }
     /// ```
     pub fn from_ascii(bytes: Bytes) -> Self {
-        Self { bytes }
+        Self {
+            bytes: bytes.clone(),
+        }
     }
 
     /// Converts a string slice containing ASCII encoded bytes to a `String`
@@ -236,7 +238,9 @@ impl String {
 
 impl From<Bytes> for String {
     fn from(b: Bytes) -> Self {
-        Self { bytes: b }
+        Self {
+            bytes: b.clone(),
+        }
     }
 }
 
@@ -308,7 +312,7 @@ impl From<String> for raw_slice {
     /// }
     /// ```
     fn from(s: String) -> raw_slice {
-        raw_slice::from(s.as_bytes())
+        s.bytes.as_raw_slice()
     }
 }
 
@@ -326,29 +330,14 @@ impl Hash for String {
 
 impl AbiEncode for String {
     fn abi_encode(self, buffer: Buffer) -> Buffer {
-        // Encode the length
-        let mut buffer = self.bytes.len().abi_encode(buffer);
-
-        // Encode each byte of the string
-        let mut i = 0;
-        while i < self.bytes.len() {
-            let item = self.bytes.get(i).unwrap();
-            buffer = item.abi_encode(buffer);
-            i += 1;
-        }
-
-        buffer
+        self.bytes.abi_encode(buffer)
     }
 }
 
 impl AbiDecode for String {
     fn abi_decode(ref mut buffer: BufferReader) -> Self {
-        // Get length and string data
-        let len = u64::abi_decode(buffer);
-        let data = buffer.read_bytes(len);
-        // Create string from the ptr and len as parts of a raw_slice
         String {
-            bytes: Bytes::from(raw_slice::from_parts::<u8>(data.ptr(), len)),
+            bytes: Bytes::abi_decode(buffer),
         }
     }
 }
diff --git a/sway-lib-std/src/tx.sw b/sway-lib-std/src/tx.sw
index 08e42bd259b..033b937ec50 100644
--- a/sway-lib-std/src/tx.sw
+++ b/sway-lib-std/src/tx.sw
@@ -3,6 +3,7 @@ library;
 
 use ::revert::revert;
 use ::option::Option::{self, *};
+use ::alloc::alloc_bytes;
 
 // GTF Opcode const selectors
 //
@@ -18,6 +19,7 @@ pub const GTF_SCRIPT_SCRIPT_DATA = 0x00A;
 pub const GTF_SCRIPT_INPUT_AT_INDEX = 0x00B;
 pub const GTF_SCRIPT_OUTPUT_AT_INDEX = 0x00C;
 pub const GTF_SCRIPT_WITNESS_AT_INDEX = 0x00D;
+
 pub const GTF_TX_LENGTH = 0x00E;
 
 // pub const GTF_CREATE_BYTECODE_WITNESS_INDEX = 0x101;
@@ -46,10 +48,35 @@ pub enum Transaction {
     Script: (),
     /// A contract deployment transaction.
     Create: (),
+    /// The transaction is created by the block producer and is not signed.
+    ///
+    /// # Additional Information
+    ///
+    /// NOTE: This should never be valid in execution but it provided for congruency to the FuelVM specs.
+    Mint: (),
+    /// The Upgrade transaction allows upgrading either consensus parameters or state transition function used by the network to produce future blocks.
+    Upgrade: (),
+    ///The Upload transaction allows the huge bytecode to be divided into subsections and uploaded slowly to the chain.
+    Upload: (),
+    /// The Blob inserts a simple binary blob in the chain. It's raw immutable data that can be cheaply loaded by the VM and used as instructions or just data.
+    Blob: (),
+}
+
+impl core::ops::Eq for Transaction {
+    fn eq(self, other: Self) -> bool {
+        match (self, other) {
+            (Transaction::Script, Transaction::Script) => true,
+            (Transaction::Create, Transaction::Create) => true,
+            (Transaction::Mint, Transaction::Mint) => true,
+            (Transaction::Upgrade, Transaction::Upgrade) => true,
+            (Transaction::Upload, Transaction::Upload) => true,
+            (Transaction::Blob, Transaction::Blob) => true,
+            _ => false,
+        }
+    }
 }
 
 /// Get the type of the current transaction.
-/// Either `Transaction::Script` or `Transaction::Create`.
 ///
 /// # Returns
 ///
@@ -73,6 +100,18 @@ pub enum Transaction {
 ///         Transaction::Create => {
 ///             log("Contract deployment transaction");
 ///         },
+///         Transaction::Mint => {
+///             log("This should never happen");
+///         },
+///         Transaction::Upgrade => {
+///             log("Upgrade transaction");
+///         },
+///         Transaction::Upload => {
+///             log("Upload transaction");
+///         },
+///         Transaction::Blob => {
+///             log("Blob transaction");
+///         },
 ///     }
 /// }
 /// ```
@@ -80,13 +119,16 @@ pub fn tx_type() -> Transaction {
     match __gtf::<u8>(0, GTF_TYPE) {
         0u8 => Transaction::Script,
         1u8 => Transaction::Create,
+        3u8 => Transaction::Upgrade,
+        4u8 => Transaction::Upload,
+        5u8 => Transaction::Blob,
         _ => revert(0),
     }
 }
 
 const TIP_POLICY: u32 = 1u32 << 0;
-const MATURITY_POLICY: u32 = 1u32 << 1;
-const WITNESS_LIMIT_POLICY: u32 = 1u32 << 2;
+const WITNESS_LIMIT_POLICY: u32 = 1u32 << 1;
+const MATURITY_POLICY: u32 = 1u32 << 2;
 const MAX_FEE_POLICY: u32 = 1u32 << 3;
 
 /// Returns policies bits. It can be used to identify which policies are set.
@@ -151,14 +193,14 @@ pub fn script_gas_limit() -> u64 {
 /// use std::tx::tx_maturity;
 ///
 /// fn foo() {
-///     let maturity = tx_maturity();
+///     let maturity = tx_maturity().unwrap();
 ///     log(maturity);
 /// }
 /// ```
-pub fn tx_maturity() -> Option<u64> {
+pub fn tx_maturity() -> Option<u32> {
     let bits = policies();
     if bits & MATURITY_POLICY > 0 {
-        Some(__gtf::<u64>(0, GTF_POLICY_MATURITY))
+        Some(__gtf::<u32>(0, GTF_POLICY_MATURITY))
     } else {
         None
     }
@@ -218,11 +260,7 @@ pub fn tx_max_fee() -> Option<u64> {
 ///
 /// # Returns
 ///
-/// * [u64] - The script length for the transaction.
-///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
+/// * [Option<u64>] - The script length for the transaction.
 ///
 /// # Examples
 ///
@@ -230,14 +268,14 @@ pub fn tx_max_fee() -> Option<u64> {
 /// use std::tx::tx_script_length;
 ///
 /// fn foo() {
-///     let script_length = tx_script_length();
+///     let script_length = tx_script_length().unwrap();
 ///     assert(script_length > 0);
 /// }
 /// ```
-pub fn tx_script_length() -> u64 {
+pub fn tx_script_length() -> Option<u64> {
     match tx_type() {
-        Transaction::Script => __gtf::<u64>(0, GTF_SCRIPT_SCRIPT_LENGTH),
-        Transaction::Create => revert(0),
+        Transaction::Script => Some(__gtf::<u64>(0, GTF_SCRIPT_SCRIPT_LENGTH)),
+        _ => None,
     }
 }
 
@@ -247,24 +285,20 @@ pub fn tx_script_length() -> u64 {
 ///
 /// * [u64] - The script data length for the transaction.
 ///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
-///
 /// # Examples
 ///
 /// ```sway
 /// use std::tx::tx_script_data_length;
 ///
 /// fn foo() {
-///     let script_data_length = tx_script_data_length();
+///     let script_data_length = tx_script_data_length().unwrap();
 ///     assert(script_data_length > 0);
 /// }
 /// ```
-pub fn tx_script_data_length() -> u64 {
+pub fn tx_script_data_length() -> Option<u64> {
     match tx_type() {
-        Transaction::Script => __gtf::<u64>(0, GTF_SCRIPT_SCRIPT_DATA_LENGTH),
-        Transaction::Create => revert(0),
+        Transaction::Script => Some(__gtf::<u64>(0, GTF_SCRIPT_SCRIPT_DATA_LENGTH)),
+        _ => None,
     }
 }
 
@@ -274,6 +308,10 @@ pub fn tx_script_data_length() -> u64 {
 ///
 /// * [u64] - The witnesses count for the transaction.
 ///
+/// # Reverts
+///
+/// * When the transaction type is unrecognized. This should never happen.
+///
 /// # Examples
 ///
 /// ```sway
@@ -288,6 +326,10 @@ pub fn tx_witnesses_count() -> u64 {
     match tx_type() {
         Transaction::Script => __gtf::<u64>(0, GTF_SCRIPT_WITNESSES_COUNT),
         Transaction::Create => __gtf::<u64>(0, GTF_CREATE_WITNESSES_COUNT),
+        Transaction::Upgrade => __gtf::<u64>(0, GTF_SCRIPT_WITNESSES_COUNT),
+        Transaction::Upload => __gtf::<u64>(0, GTF_SCRIPT_WITNESSES_COUNT),
+        Transaction::Blob => __gtf::<u64>(0, GTF_SCRIPT_WITNESSES_COUNT),
+        _ => revert(0),
     }
 }
 
@@ -299,7 +341,7 @@ pub fn tx_witnesses_count() -> u64 {
 ///
 /// # Returns
 ///
-/// * [u64] - The pointer to the witness at index `index`.
+/// * [Option<raw_ptr>] - The pointer to the witness at index `index`.
 ///
 /// # Examples
 ///
@@ -307,14 +349,22 @@ pub fn tx_witnesses_count() -> u64 {
 /// use std::tx::tx_witness_pointer;
 ///
 /// fn foo() {
-///     let witness_pointer = tx_witness_pointer(0);
-///     log(witness_pointer);
+///     let witness_pointer = tx_witness_pointer(0).unwrap();
 /// }
 /// ```
-pub fn tx_witness_pointer(index: u64) -> u64 {
+#[allow(dead_code)]
+fn tx_witness_pointer(index: u64) -> Option<raw_ptr> {
+    if index >= tx_witnesses_count() {
+        return None
+    }
+
     match tx_type() {
-        Transaction::Script => __gtf::<u64>(index, GTF_SCRIPT_WITNESS_AT_INDEX),
-        Transaction::Create => __gtf::<u64>(index, GTF_CREATE_WITNESS_AT_INDEX),
+        Transaction::Script => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_WITNESS_AT_INDEX)),
+        Transaction::Create => Some(__gtf::<raw_ptr>(index, GTF_CREATE_WITNESS_AT_INDEX)),
+        Transaction::Upgrade => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_WITNESS_AT_INDEX)),
+        Transaction::Upload => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_WITNESS_AT_INDEX)),
+        Transaction::Blob => Some(__gtf::<raw_ptr>(index, GTF_SCRIPT_WITNESS_AT_INDEX)),
+        _ => None,
     }
 }
 
@@ -326,7 +376,7 @@ pub fn tx_witness_pointer(index: u64) -> u64 {
 ///
 /// # Returns
 ///
-/// * [u64] - The length of the witness data at `index`.
+/// * [Option<64>] - The length of the witness data at `index`.
 ///
 /// # Examples
 ///
@@ -334,23 +384,32 @@ pub fn tx_witness_pointer(index: u64) -> u64 {
 /// use std::tx::tx_witness_data_length;
 ///
 /// fn foo() {
-///     let witness_data_length = tx_witness_data_length(0);
+///     let witness_data_length = tx_witness_data_length(0).unwrap();
 ///     log(witness_data_length);
 /// }
 /// ```
-pub fn tx_witness_data_length(index: u64) -> u64 {
-    __gtf::<u64>(index, GTF_WITNESS_DATA_LENGTH)
+pub fn tx_witness_data_length(index: u64) -> Option<u64> {
+    if index >= tx_witnesses_count() {
+        return None
+    }
+
+    Some(__gtf::<u64>(index, GTF_WITNESS_DATA_LENGTH))
 }
 
 /// Get the witness data at `index`.
 ///
+/// # Additional Information
+///
+/// **Unsafe. Assumes the type is correct.**
+/// This function does not support ownership types(Vec, Bytes, String, etc).
+///
 /// # Arguments
 ///
 /// * `index` - The index of the witness to get the data for.
 ///
 /// # Returns
 ///
-/// * [T] - The witness data at `index`.
+/// * [Option<T>] - The witness data at `index`.
 ///
 /// # Examples
 ///
@@ -358,15 +417,35 @@ pub fn tx_witness_data_length(index: u64) -> u64 {
 /// use std::tx::tx_witness_data;
 ///
 /// fn foo() {
-///     let witness_data: u64 = tx_witness_data(0);
+///     let witness_data: u64 = tx_witness_data(0).unwrap();
 ///     log(witness_data);
 /// }
 /// ```
-pub fn tx_witness_data<T>(index: u64) -> T {
-    if __size_of::<T>() == 1 {
-        __gtf::<raw_ptr>(index, GTF_WITNESS_DATA).add::<u8>(7).read::<T>()
+pub fn tx_witness_data<T>(index: u64) -> Option<T> {
+    if index >= tx_witnesses_count() {
+        return None
+    }
+
+    let length = match tx_witness_data_length(index) {
+        Some(len) => len,
+        None => return None,
+    };
+
+    if __is_reference_type::<T>() {
+        let witness_data_ptr = __gtf::<raw_ptr>(index, GTF_WITNESS_DATA);
+        let new_ptr = alloc_bytes(length);
+        witness_data_ptr.copy_bytes_to(new_ptr, length);
+
+        Some(asm(ptr: new_ptr) {
+            ptr: T
+        })
     } else {
-        __gtf::<raw_ptr>(index, GTF_WITNESS_DATA).read::<T>()
+        // u8 is the only value type that is less than 8 bytes and should be handled separately
+        if __size_of::<T>() == 1 {
+            Some(__gtf::<raw_ptr>(index, GTF_WITNESS_DATA).add::<u8>(7).read::<T>())
+        } else {
+            Some(__gtf::<raw_ptr>(index, GTF_WITNESS_DATA).read::<T>())
+        }
     }
 }
 
@@ -374,11 +453,7 @@ pub fn tx_witness_data<T>(index: u64) -> T {
 ///
 /// # Returns
 ///
-/// * [raw_ptr] - The transaction script start pointer.
-///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
+/// * [Option<raw_ptr>] - The transaction script start pointer.
 ///
 /// # Examples
 ///
@@ -386,14 +461,14 @@ pub fn tx_witness_data<T>(index: u64) -> T {
 /// use std::tx::tx_script_start_pointer;
 ///
 /// fn foo() {
-///     let script_start_pointer = tx_script_start_pointer();
+///     let script_start_pointer = tx_script_start_pointer().unwrap();
 ///     log(script_start_pointer);
 /// }
 /// ```
-pub fn tx_script_start_pointer() -> raw_ptr {
+fn tx_script_start_pointer() -> Option<raw_ptr> {
     match tx_type() {
-        Transaction::Script => __gtf::<raw_ptr>(0, GTF_SCRIPT_SCRIPT),
-        _ => revert(0),
+        Transaction::Script => Some(__gtf::<raw_ptr>(0, GTF_SCRIPT_SCRIPT)),
+        _ => None,
     }
 }
 
@@ -401,11 +476,7 @@ pub fn tx_script_start_pointer() -> raw_ptr {
 ///
 /// # Returns
 ///
-/// * [raw_ptr] - The transaction script data start pointer.
-///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
+/// * [Option<raw_ptr>] - The transaction script data start pointer.
 ///
 /// # Examples
 ///
@@ -413,17 +484,14 @@ pub fn tx_script_start_pointer() -> raw_ptr {
 /// use std::tx::tx_script_data_start_pointer;
 ///
 /// fn foo() {
-///     let script_data_start_pointer = tx_script_data_start_pointer();
+///     let script_data_start_pointer = tx_script_data_start_pointer().unwrap();
 ///     log(script_data_start_pointer);
 /// }
 /// ```
-pub fn tx_script_data_start_pointer() -> raw_ptr {
+fn tx_script_data_start_pointer() -> Option<raw_ptr> {
     match tx_type() {
-        Transaction::Script => __gtf::<raw_ptr>(0, GTF_SCRIPT_SCRIPT_DATA),
-        _ => {
-            // transaction-create has no script data length
-            revert(0);
-        }
+        Transaction::Script => Some(__gtf::<raw_ptr>(0, GTF_SCRIPT_SCRIPT_DATA)),
+        _ => None,
     }
 }
 
@@ -431,16 +499,12 @@ pub fn tx_script_data_start_pointer() -> raw_ptr {
 ///
 /// # Additional Information
 ///
-/// **Unsafe.**
-/// **Assumes the type is correct.**
+/// **Unsafe. Assumes the type is correct.**
+/// This function does not support ownership types(Vec, Bytes, String, etc).
 ///
 /// # Returns
 ///
-/// * [T] - The script data, typed.
-///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
+/// * [Option<T>] - The script data, typed.
 ///
 /// # Examples
 ///
@@ -452,10 +516,14 @@ pub fn tx_script_data_start_pointer() -> raw_ptr {
 ///     log(script_data);
 /// }
 /// ```
-pub fn tx_script_data<T>() -> T {
+pub fn tx_script_data<T>() -> Option<T> {
     let ptr = tx_script_data_start_pointer();
+    if ptr.is_none() {
+        return None
+    }
+
     // TODO some safety checks on the input data? We are going to assume it is the right type for now.
-    ptr.read::<T>()
+    Some(ptr.unwrap().read::<T>())
 }
 
 /// Get the script bytecode.
@@ -467,11 +535,7 @@ pub fn tx_script_data<T>() -> T {
 ///
 /// # Returns
 ///
-/// * [T] - The script bytecode.
-///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
+/// * [Option<T>] - The script bytecode.
 ///
 /// # Examples
 ///
@@ -479,24 +543,22 @@ pub fn tx_script_data<T>() -> T {
 /// use std::tx::tx_script_bytecode;
 ///
 /// fn foo() {
-///     let script_bytecode: [u64; 64] = tx_script_bytecode();
+///     let script_bytecode: [u64; 64] = tx_script_bytecode().unwrap();
 ///     log(script_bytecode);
 /// }
 /// ```
-pub fn tx_script_bytecode<T>() -> T {
-    tx_script_start_pointer().read::<T>()
+pub fn tx_script_bytecode<T>() -> Option<T> {
+    match tx_type() {
+        Transaction::Script => Some(tx_script_start_pointer().unwrap().read::<T>()),
+        _ => None,
+    }
 }
 
 /// Get the hash of the script bytecode.
-/// Reverts if not a transaction-script.
 ///
 /// # Returns
 ///
-/// * [b256] - The hash of the script bytecode.
-///
-/// # Reverts
-///
-/// * When the transaction type is of type `Transaction::Create`.
+/// * [Option<b256>] - The hash of the script bytecode.
 ///
 /// # Examples
 ///
@@ -504,25 +566,27 @@ pub fn tx_script_bytecode<T>() -> T {
 /// use std::tx::tx_script_bytecode_hash;
 ///
 /// fn foo() {
-///     let script_bytecode_hash: b256 = tx_script_bytecode_hash();
+///     let script_bytecode_hash: b256 = tx_script_bytecode_hash().unwrap();
 ///     assert(script_bytecode_hash == 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef);
 /// }
 /// ```
-pub fn tx_script_bytecode_hash() -> b256 {
+pub fn tx_script_bytecode_hash() -> Option<b256> {
     match tx_type() {
         Transaction::Script => {
             // Get the script memory details
             let mut result_buffer = b256::zero();
-            let script_length = tx_script_length();
-            let script_ptr = tx_script_start_pointer();
+            let script_length = tx_script_length().unwrap();
+            let script_ptr = tx_script_start_pointer().unwrap();
 
             // Run the hash opcode for the script in memory
-            asm(hash: result_buffer, ptr: script_ptr, len: script_length) {
-                s256 hash ptr len;
-                hash: b256
-            }
+            Some(
+                asm(hash: result_buffer, ptr: script_ptr, len: script_length) {
+                    s256 hash ptr len;
+                    hash: b256
+                },
+            )
         },
-        _ => revert(0),
+        _ => None,
     }
 }
 
diff --git a/sway-lib-std/src/u128.sw b/sway-lib-std/src/u128.sw
index 94a27c98027..8eb22317b64 100644
--- a/sway-lib-std/src/u128.sw
+++ b/sway-lib-std/src/u128.sw
@@ -3,9 +3,16 @@ library;
 
 use ::assert::assert;
 use ::convert::{From, Into};
-use ::flags::{disable_panic_on_overflow, set_flags};
+use ::flags::{
+    disable_panic_on_overflow,
+    panic_on_overflow_enabled,
+    panic_on_unsafe_math_enabled,
+    set_flags,
+};
+use ::registers::{flags, overflow};
 use ::math::*;
 use ::result::Result::{self, *};
+use ::option::Option::{self, None, Some};
 
 /// The 128-bit unsigned integer type.
 ///
@@ -550,8 +557,11 @@ impl core::ops::Add for U128 {
     fn add(self, other: Self) -> Self {
         let mut upper_128 = self.upper.overflowing_add(other.upper);
 
-        // If the upper overflows, then the number cannot fit in 128 bits, so panic.
-        assert(upper_128.upper == 0);
+        if panic_on_overflow_enabled() {
+            // If the upper overflows, then the number cannot fit in 128 bits, so panic.
+            assert(upper_128.upper == 0);
+        }
+
         let lower_128 = self.lower.overflowing_add(other.lower);
 
         // If overflow has occurred in the lower component addition, carry.
@@ -560,8 +570,10 @@ impl core::ops::Add for U128 {
             upper_128 = upper_128.lower.overflowing_add(lower_128.upper);
         }
 
-        // If overflow has occurred in the upper component addition, panic.
-        assert(upper_128.upper == 0);
+        if panic_on_overflow_enabled() {
+            // If overflow has occurred in the upper component addition, panic.
+            assert(upper_128.upper == 0);
+        }
 
         Self {
             upper: upper_128.lower,
@@ -571,10 +583,13 @@ impl core::ops::Add for U128 {
 }
 
 impl core::ops::Subtract for U128 {
-    /// Subtract a `U128` from a `U128`. Reverts of overflow.
+    /// Subtract a `U128` from a `U128`. Reverts on underflow.
     fn subtract(self, other: Self) -> Self {
-        // If trying to subtract a larger number, panic.
-        assert(!(self < other));
+        // panic_on_overflow_enabled is also for underflow
+        if panic_on_overflow_enabled() {
+            // If trying to subtract a larger number, panic.
+            assert(!(self < other));
+        }
 
         let mut upper = self.upper - other.upper;
         let mut lower = 0;
@@ -596,7 +611,9 @@ impl core::ops::Multiply for U128 {
         // in case both of the `U128` upper parts are bigger than zero,
         // it automatically means overflow, as any `U128` value
         // is upper part multiplied by 2 ^ 64 + lower part
-        assert(self.upper == 0 || other.upper == 0);
+        if panic_on_unsafe_math_enabled() {
+            assert(self.upper == 0 || other.upper == 0);
+        }
 
         let mut result = self.lower.overflowing_mul(other.lower);
         if self.upper == 0 {
@@ -616,7 +633,13 @@ impl core::ops::Divide for U128 {
     fn divide(self, divisor: Self) -> Self {
         let zero = Self::from((0, 0));
 
-        assert(divisor != zero);
+        if panic_on_unsafe_math_enabled() {
+            assert(divisor != zero);
+        } else {
+            if divisor == zero {
+                return zero;
+            }
+        }
 
         if self.upper == 0 && divisor.upper == 0 {
             return Self::from((0, self.lower / divisor.lower));
@@ -645,6 +668,48 @@ impl core::ops::Divide for U128 {
     }
 }
 
+fn u64_checked_add(a: u64, b: u64) -> Option<u64> {
+    let of = asm(a: a, b: b, res) {
+        add res a b;
+        of: u64
+    };
+
+    if of != 0 {
+        return None;
+    }
+
+    Some(a + b)
+}
+
+fn u128_checked_mul(a: U128, b: U128) -> Option<U128> {
+    // in case both of the `U128` upper parts are bigger than zero,
+    // it automatically means overflow, as any `U128` value
+    // is upper part multiplied by 2 ^ 64 + lower part
+    if a.upper != 0 || b.upper != 0 {
+        return None
+    }
+
+    let mut result = a.lower.overflowing_mul(b.lower);
+
+    if a.upper == 0 {
+        match u64_checked_add(result.upper, a.lower * b.upper) {
+            None => return None,
+            Some(v) => {
+                result.upper = v
+            }
+        }
+    } else if b.upper == 0 {
+        match u64_checked_add(result.upper, a.upper * b.lower) {
+            None => return None,
+            Some(v) => {
+                result.upper = v
+            }
+        }
+    }
+
+    Some(result)
+}
+
 impl Power for U128 {
     fn pow(self, exponent: u32) -> Self {
         let mut value = self;
@@ -661,7 +726,10 @@ impl Power for U128 {
         }
 
         while exp & 1 == 0 {
-            value = value * value;
+            match u128_checked_mul(value, value) {
+                None => return U128::zero(),
+                Some(v) => value = v,
+            };
             exp >>= 1;
         }
 
@@ -672,9 +740,15 @@ impl Power for U128 {
         let mut acc = value;
         while exp > 1 {
             exp >>= 1;
-            value = value * value;
+            match u128_checked_mul(value, value) {
+                None => return U128::zero(),
+                Some(v) => value = v,
+            };
             if exp & 1 == 1 {
-                acc = acc * value;
+                match u128_checked_mul(acc, value) {
+                    None => return U128::zero(),
+                    Some(v) => acc = v,
+                };
             }
         }
         acc
@@ -713,8 +787,14 @@ impl BinaryLogarithm for U128 {
     fn log2(self) -> Self {
         let zero = Self::from((0, 0));
         let mut res = zero;
-        // If trying to get a log2(0), panic, as infinity is not a number.
-        assert(self != zero);
+        // If panic on unsafe math is enabled, only then revert
+        if panic_on_unsafe_math_enabled() {
+            assert(self != zero);
+        } else {
+            if self == zero {
+                return zero;
+            }
+        }
         if self.upper != 0 {
             res = Self::from((0, self.upper.log(2) + 64));
         } else if self.lower != 0 {
@@ -726,8 +806,71 @@ impl BinaryLogarithm for U128 {
 
 impl Logarithm for U128 {
     fn log(self, base: Self) -> Self {
+        let flags = disable_panic_on_overflow();
+
+        // If panic on unsafe math is enabled, only then revert
+        if panic_on_unsafe_math_enabled() {
+            // Logarithm is undefined for bases less than 2
+            assert(base >= U128::from(2_u64));
+            // Logarithm is undefined for 0
+            assert(self != U128::zero());
+        } else {
+            // Logarithm is undefined for bases less than 2
+            // Logarithm is undefined for 0
+            if (base < U128::from(2_u64)) || (self == U128::zero()) {
+                set_flags(flags);
+                return U128::zero();
+            }
+        }
+
+        // Decimals rounded to 0
+        if self < base {
+            set_flags(flags);
+            return U128::zero();
+        }
+
+        // Estimating the result using change of base formula. Only an estimate because we are doing uint calculations.
         let self_log2 = self.log2();
         let base_log2 = base.log2();
-        self_log2 / base_log2
+        let mut result = (self_log2 / base_log2);
+
+        // Converting u128 to u32, this cannot fail as the result will be atmost ~128
+        let parts: (u64, u64) = result.into();
+        let res_u32 = asm(r1: parts.1) {
+            r1: u32
+        };
+
+        // Raising the base to the power of the result
+        let mut pow_res = base.pow(res_u32);
+        let mut of = overflow();
+
+        // Adjusting the result until the power is less than or equal to self
+        // If pow_res is > than self, then there is an overestimation. If there is an overflow then there is definitely an overestimation.
+        while (pow_res > self) || (of > 0) {
+            result -= U128::from(1_u64);
+
+            // Converting u128 to u32, this cannot fail as the result will be atmost ~128
+            let parts: (u64, u64) = result.into();
+            let res_u32 = asm(r1: parts.1) {
+                r1: u32
+            };
+
+            pow_res = base.pow(res_u32);
+            of = overflow();
+        };
+
+        set_flags(flags);
+
+        result
+    }
+}
+
+impl core::ops::TotalOrd for U128 {
+    fn min(self, other: Self) -> Self {
+        if self < other { self } else { other }
+    }
+
+    fn max(self, other: Self) -> Self {
+        if self > other { self } else { other }
     }
 }
diff --git a/sway-lib-std/src/vec.sw b/sway-lib-std/src/vec.sw
index 491e8a728e5..8ae7fe65da7 100644
--- a/sway-lib-std/src/vec.sw
+++ b/sway-lib-std/src/vec.sw
@@ -131,14 +131,16 @@ impl<T> RawVec<T> {
 
 impl<T> From<raw_slice> for RawVec<T> {
     fn from(slice: raw_slice) -> Self {
-        Self {
-            ptr: slice.ptr(),
-            cap: slice.len::<T>(),
+        let cap = slice.len::<T>();
+        let ptr = alloc::<T>(cap);
+        if cap > 0 {
+            slice.ptr().copy_to::<T>(ptr, cap);
         }
+        Self { ptr, cap }
     }
 }
 
-/// A contiguous growable array type, written as `Vec<T>`, short for 'vector'.
+/// A contiguous growable array type, written as `Vec<T>`, short for 'vector'. It has ownership over its buffer.
 pub struct Vec<T> {
     buf: RawVec<T>,
     len: u64,
@@ -419,7 +421,7 @@ impl<T> Vec<T> {
         // Shift everything down to fill in that spot.
         let mut i = index;
         if self.len > 1 {
-            while i < self.len {
+            while i < self.len - 1 {
                 let ptr = buf_start.add::<T>(i);
                 ptr.add::<T>(1).copy_to::<T>(ptr, 1);
                 i += 1;
@@ -702,3 +704,28 @@ impl<T> Iterator for VecIter<T> {
         self.values.get(self.index - 1)
     }
 }
+
+// TODO: Uncomment when fixed. https://github.com/FuelLabs/sway/issues/6567
+// #[test]
+// fn ok_vec_buffer_ownership() {
+//     let mut original_array = [1u8, 2u8, 3u8, 4u8];
+//     let slice = raw_slice::from_parts::<u8>(__addr_of(original_array), 4);
+
+//     // Check Vec duplicates the original slice
+//     let mut bytes = Vec::<u8>::from(slice);
+//     bytes.set(0, 5);
+//     assert(original_array[0] == 1);
+
+//     // At this point, slice equals [5, 2, 3, 4]
+//     let encoded_slice = encode(bytes);
+
+//     // `Vec<u8>` should duplicate the underlying buffer,
+//     // so when we write to it, it should not change
+//     // `encoded_slice` 
+//     let mut bytes = abi_decode::<Vec<u8>>(encoded_slice);
+//     bytes.set(0, 6);
+//     assert(bytes.get(0) == Some(6));
+
+//     let mut bytes = abi_decode::<Vec<u8>>(encoded_slice);
+//     assert(bytes.get(0) == Some(5));
+// }
diff --git a/sway-lsp/Cargo.toml b/sway-lsp/Cargo.toml
index fa3ad3287d0..f9648768eb5 100644
--- a/sway-lsp/Cargo.toml
+++ b/sway-lsp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-lsp"
-version = "0.60.0"
+version.workspace = true
 description = "LSP server for Sway."
 authors.workspace = true
 edition.workspace = true
@@ -9,36 +9,35 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1.0.41"
-crossbeam-channel = "0.5"
-dashmap = "5.4"
-fd-lock = "4.0"
-forc-pkg = { version = "0.60.0", path = "../forc-pkg" }
-forc-tracing = { version = "0.60.0", path = "../forc-tracing" }
-forc-util = { version = "0.60.0", path = "../forc-util" }
-indexmap = { version = "2.0.0", features = ["rayon"] }
-lsp-types = { version = "0.94", features = ["proposed"] }
-notify = "5.0.0"
-notify-debouncer-mini = { version = "0.2.0" }
-parking_lot = "0.12.1"
-proc-macro2 = "1.0.5"
-quote = "1.0.9"
-rayon = "1.5.0"
-rayon-cond = "0.3"
-ropey = "1.2"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.60"
-sway-ast = { version = "0.60.0", path = "../sway-ast" }
-sway-core = { version = "0.60.0", path = "../sway-core" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-parse = { version = "0.60.0", path = "../sway-parse" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-swayfmt = { version = "0.60.0", path = "../swayfmt" }
-syn = { version = "1.0.73", features = ["full"] }
-tempfile = "3"
-thiserror = "1.0.30"
-tokio = { version = "1.3", features = [
+anyhow.workspace = true
+crossbeam-channel.workspace = true
+dashmap.workspace = true
+fd-lock.workspace = true
+forc-pkg.workspace = true
+forc-tracing.workspace = true
+forc-util.workspace = true
+indexmap = { workspace = true, features = ["rayon"] }
+lsp-types = { workspace = true, features = ["proposed"] }
+notify.workspace = true
+notify-debouncer-mini.workspace = true
+parking_lot.workspace = true
+proc-macro2.workspace = true
+quote.workspace = true
+rayon.workspace = true
+rayon-cond.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+sway-ast.workspace = true
+sway-core.workspace = true
+sway-error.workspace = true
+sway-parse.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+swayfmt.workspace = true
+syn = { workspace = true, features = ["full"] }
+tempfile.workspace = true
+thiserror.workspace = true
+tokio = { workspace = true, features = [
     "fs",
     "io-std",
     "io-util",
@@ -48,13 +47,14 @@ tokio = { version = "1.3", features = [
     "sync",
     "time",
 ] }
-toml_edit = "0.19"
-tower-lsp = { version = "0.20", features = ["proposed"] }
-tracing = "0.1"
-urlencoding = "2.1.2"
+toml_edit.workspace = true
+tower-lsp = { workspace = true, features = ["proposed"] }
+tracing.workspace = true
+urlencoding.workspace = true
 
 [dev-dependencies]
 assert-json-diff = "2.0"
+codspeed-criterion-compat = "2.6.0"
 criterion = "0.5"
 dirs = "4.0"
 futures = { version = "0.3", default-features = false, features = [
@@ -65,7 +65,7 @@ pretty_assertions = "1.4.0"
 rand = "0.8"
 regex = "^1.10.2"
 sway-lsp-test-utils = { path = "tests/utils" }
-tikv-jemallocator = "0.5"
+tikv-jemallocator = "0.6"
 tower = { version = "0.4.12", default-features = false, features = ["util"] }
 
 [[bench]]
diff --git a/sway-lsp/README.md b/sway-lsp/README.md
index 8225e90e8f1..940ec11a269 100644
--- a/sway-lsp/README.md
+++ b/sway-lsp/README.md
@@ -8,7 +8,7 @@ This extension provides LSP support for the Sway smart contract programming lang
 
 ## Features
 
-- goto type definition 
+- go-to type definition 
 - types and documentation on hover
 - inlay hints for types and parameter names
 - semantic syntax highlighting
diff --git a/sway-lsp/benches/bench_main.rs b/sway-lsp/benches/bench_main.rs
index 1a767ac6792..b2970311fff 100644
--- a/sway-lsp/benches/bench_main.rs
+++ b/sway-lsp/benches/bench_main.rs
@@ -1,5 +1,7 @@
+#![recursion_limit = "256"]
+
 mod lsp_benchmarks;
-use criterion::criterion_main;
+use codspeed_criterion_compat::criterion_main;
 
 // Use Jemalloc during benchmarks
 #[global_allocator]
diff --git a/sway-lsp/benches/lsp_benchmarks/compile.rs b/sway-lsp/benches/lsp_benchmarks/compile.rs
index 6916582e271..315d562b55a 100644
--- a/sway-lsp/benches/lsp_benchmarks/compile.rs
+++ b/sway-lsp/benches/lsp_benchmarks/compile.rs
@@ -1,27 +1,36 @@
-use criterion::{black_box, criterion_group, Criterion};
-use lsp_types::Url;
+use codspeed_criterion_compat::{black_box, criterion_group, Criterion};
 use std::sync::Arc;
 use sway_core::{Engines, ExperimentalFlags};
 use sway_lsp::core::session;
+use tokio::runtime::Runtime;
 
 const NUM_DID_CHANGE_ITERATIONS: usize = 10;
 
 fn benchmarks(c: &mut Criterion) {
-    let experimental = ExperimentalFlags {
-        new_encoding: false,
-    };
+    let (uri, session, _) = Runtime::new()
+        .unwrap()
+        .block_on(async { black_box(super::compile_test_project().await) });
+
+    let build_plan = session
+        .build_plan_cache
+        .get_or_update(&session.sync.manifest_path(), || session::build_plan(&uri))
+        .unwrap();
 
-    // Load the test project
-    let uri = Url::from_file_path(super::benchmark_dir().join("src/main.sw")).unwrap();
     let mut lsp_mode = Some(sway_core::LspConfig {
         optimized_build: false,
         file_versions: Default::default(),
     });
+
+    let experimental = ExperimentalFlags {
+        new_encoding: false,
+    };
+
     c.bench_function("compile", |b| {
         b.iter(|| {
             let engines = Engines::default();
             let _ = black_box(
-                session::compile(&uri, &engines, None, lsp_mode.clone(), experimental).unwrap(),
+                session::compile(&build_plan, &engines, None, lsp_mode.as_ref(), experimental)
+                    .unwrap(),
             );
         })
     });
@@ -29,12 +38,19 @@ fn benchmarks(c: &mut Criterion) {
     c.bench_function("traverse", |b| {
         let engines = Engines::default();
         let results = black_box(
-            session::compile(&uri, &engines, None, lsp_mode.clone(), experimental).unwrap(),
+            session::compile(&build_plan, &engines, None, lsp_mode.as_ref(), experimental).unwrap(),
         );
         let session = Arc::new(session::Session::new());
         b.iter(|| {
-            let _ =
-                black_box(session::traverse(results.clone(), &engines, session.clone()).unwrap());
+            let _ = black_box(
+                session::traverse(
+                    results.clone(),
+                    &engines,
+                    session.clone(),
+                    lsp_mode.as_ref(),
+                )
+                .unwrap(),
+            );
         })
     });
 
@@ -44,7 +60,8 @@ fn benchmarks(c: &mut Criterion) {
         b.iter(|| {
             for _ in 0..NUM_DID_CHANGE_ITERATIONS {
                 let _ = black_box(
-                    session::compile(&uri, &engines, None, lsp_mode.clone(), experimental).unwrap(),
+                    session::compile(&build_plan, &engines, None, lsp_mode.as_ref(), experimental)
+                        .unwrap(),
                 );
             }
         })
diff --git a/sway-lsp/benches/lsp_benchmarks/requests.rs b/sway-lsp/benches/lsp_benchmarks/requests.rs
index cc6fae96f58..c2c79eaf25c 100644
--- a/sway-lsp/benches/lsp_benchmarks/requests.rs
+++ b/sway-lsp/benches/lsp_benchmarks/requests.rs
@@ -1,9 +1,11 @@
-use criterion::{black_box, criterion_group, Criterion};
+use codspeed_criterion_compat::{black_box, criterion_group, Criterion};
 use lsp_types::{
     CompletionResponse, DocumentSymbolResponse, Position, Range, TextDocumentContentChangeEvent,
     TextDocumentIdentifier,
 };
-use sway_lsp::{capabilities, lsp_ext::OnEnterParams, utils::keyword_docs::KeywordDocs};
+use sway_lsp::{
+    capabilities, config::LspClient, lsp_ext::OnEnterParams, utils::keyword_docs::KeywordDocs,
+};
 use tokio::runtime::Runtime;
 
 fn benchmarks(c: &mut Criterion) {
@@ -37,13 +39,25 @@ fn benchmarks(c: &mut Criterion) {
     });
 
     c.bench_function("hover", |b| {
-        b.iter(|| capabilities::hover::hover_data(session.clone(), &keyword_docs, &uri, position))
+        b.iter(|| {
+            capabilities::hover::hover_data(
+                session.clone(),
+                &keyword_docs,
+                &uri,
+                position,
+                LspClient::default(),
+            )
+        })
     });
 
     c.bench_function("highlight", |b| {
         b.iter(|| capabilities::highlight::get_highlights(session.clone(), &uri, position))
     });
 
+    c.bench_function("find_all_references", |b| {
+        b.iter(|| session.token_references(&uri, position))
+    });
+
     c.bench_function("goto_definition", |b| {
         b.iter(|| session.token_definition_response(&uri, position))
     });
diff --git a/sway-lsp/benches/lsp_benchmarks/token_map.rs b/sway-lsp/benches/lsp_benchmarks/token_map.rs
index 79182e239a2..fd4423b90fa 100644
--- a/sway-lsp/benches/lsp_benchmarks/token_map.rs
+++ b/sway-lsp/benches/lsp_benchmarks/token_map.rs
@@ -1,4 +1,4 @@
-use criterion::{black_box, criterion_group, Criterion};
+use codspeed_criterion_compat::{black_box, criterion_group, Criterion};
 use lsp_types::Position;
 use tokio::runtime::Runtime;
 
diff --git a/sway-lsp/src/capabilities/code_actions/diagnostic/auto_import.rs b/sway-lsp/src/capabilities/code_actions/diagnostic/auto_import.rs
index 06aecd9a80d..22889c6eea6 100644
--- a/sway-lsp/src/capabilities/code_actions/diagnostic/auto_import.rs
+++ b/sway-lsp/src/capabilities/code_actions/diagnostic/auto_import.rs
@@ -118,6 +118,27 @@ pub(crate) fn get_call_paths_for_name<'s>(
                                 trait_decl.call_path.to_import_path(ctx.engines, &namespace);
                             Some(call_path)
                         }
+                        TyDecl::FunctionDecl(decl) => {
+                            let function_decl = ctx.engines.de().get_function(&decl.decl_id);
+                            let call_path = function_decl
+                                .call_path
+                                .to_import_path(ctx.engines, &namespace);
+                            Some(call_path)
+                        }
+                        TyDecl::ConstantDecl(decl) => {
+                            let constant_decl = ctx.engines.de().get_constant(&decl.decl_id);
+                            let call_path = constant_decl
+                                .call_path
+                                .to_import_path(ctx.engines, &namespace);
+                            Some(call_path)
+                        }
+                        TyDecl::TypeAliasDecl(decl) => {
+                            let type_alias_decl = ctx.engines.de().get_type_alias(&decl.decl_id);
+                            let call_path = type_alias_decl
+                                .call_path
+                                .to_import_path(ctx.engines, &namespace);
+                            Some(call_path)
+                        }
                         _ => None,
                     };
                 }
diff --git a/sway-lsp/src/capabilities/code_actions/struct_decl/struct_new.rs b/sway-lsp/src/capabilities/code_actions/struct_decl/struct_new.rs
index 5b2fbc8671a..2ad3674f68f 100644
--- a/sway-lsp/src/capabilities/code_actions/struct_decl/struct_new.rs
+++ b/sway-lsp/src/capabilities/code_actions/struct_decl/struct_new.rs
@@ -6,13 +6,13 @@ use crate::{
     core::{token::TypedAstToken, token_map::TokenMapExt},
 };
 use lsp_types::{CodeActionDisabled, Position, Range, Url};
-use sway_core::language::ty::{self, TyImplTrait, TyStructDecl, TyStructField};
+use sway_core::language::ty::{self, TyImplSelfOrTrait, TyStructDecl, TyStructField};
 use sway_types::{LineCol, Spanned};
 
 pub(crate) struct StructNewCodeAction<'a> {
     decl: &'a TyStructDecl,
     uri: &'a Url,
-    existing_impl_decl: Option<TyImplTrait>,
+    existing_impl_decl: Option<TyImplSelfOrTrait>,
 }
 
 impl<'a> GenerateImplCodeAction<'a, TyStructDecl> for StructNewCodeAction<'a> {
@@ -31,11 +31,11 @@ impl<'a> CodeAction<'a, TyStructDecl> for StructNewCodeAction<'a> {
             .iter()
             .all_references_of_token(ctx.token, ctx.engines)
             .find_map(|item| {
-                if let Some(TypedAstToken::TypedDeclaration(ty::TyDecl::ImplTrait(
-                    ty::ImplTrait { decl_id, .. },
+                if let Some(TypedAstToken::TypedDeclaration(ty::TyDecl::ImplSelfOrTrait(
+                    ty::ImplSelfOrTrait { decl_id, .. },
                 ))) = item.value().typed
                 {
-                    Some((*ctx.engines.de().get_impl_trait(&decl_id)).clone())
+                    Some((*ctx.engines.de().get_impl_self_or_trait(&decl_id)).clone())
                 } else {
                     None
                 }
diff --git a/sway-lsp/src/capabilities/code_lens.rs b/sway-lsp/src/capabilities/code_lens.rs
index d4c92c52648..f8a81e3476c 100644
--- a/sway-lsp/src/capabilities/code_lens.rs
+++ b/sway-lsp/src/capabilities/code_lens.rs
@@ -5,6 +5,7 @@ use lsp_types::{CodeLens, Url};
 use crate::core::session::Session;
 
 pub fn code_lens(session: &Arc<Session>, url: &Url) -> Vec<CodeLens> {
+    let _p = tracing::trace_span!("code_lens").entered();
     let url_path = PathBuf::from(url.path());
 
     // Construct code lenses for runnable functions
diff --git a/sway-lsp/src/capabilities/completion.rs b/sway-lsp/src/capabilities/completion.rs
index d77bd22cfad..a2b77814cb9 100644
--- a/sway-lsp/src/capabilities/completion.rs
+++ b/sway-lsp/src/capabilities/completion.rs
@@ -30,8 +30,8 @@ fn completion_items_for_type_id(
 ) -> Vec<CompletionItem> {
     let mut completion_items = vec![];
     let type_info = engines.te().get(type_id);
-    if let TypeInfo::Struct(decl_ref) = &*type_info {
-        let struct_decl = engines.de().get_struct(&decl_ref.id().clone());
+    if let TypeInfo::Struct(decl_id) = &*type_info {
+        let struct_decl = engines.de().get_struct(&decl_id.clone());
         for field in &struct_decl.fields {
             let item = CompletionItem {
                 kind: Some(CompletionItemKind::FIELD),
@@ -167,8 +167,8 @@ fn type_id_of_raw_ident(
                     }
                     None
                 });
-        } else if let TypeInfo::Struct(decl_ref) = &*engines.te().get(curr_type_id.unwrap()) {
-            let struct_decl = engines.de().get_struct(&decl_ref.id().clone());
+        } else if let TypeInfo::Struct(decl_id) = &*engines.te().get(curr_type_id.unwrap()) {
+            let struct_decl = engines.de().get_struct(&decl_id.clone());
             curr_type_id = struct_decl
                 .fields
                 .iter()
diff --git a/sway-lsp/src/capabilities/diagnostic.rs b/sway-lsp/src/capabilities/diagnostic.rs
index d5121d21914..5bdeee39fe8 100644
--- a/sway-lsp/src/capabilities/diagnostic.rs
+++ b/sway-lsp/src/capabilities/diagnostic.rs
@@ -61,7 +61,6 @@ pub fn get_diagnostics(
             diagnostics.entry(path).or_default().errors.push(diagnostic);
         }
     }
-
     diagnostics
 }
 
diff --git a/sway-lsp/src/capabilities/formatting.rs b/sway-lsp/src/capabilities/formatting.rs
index 9214da23ae3..e4b1596991b 100644
--- a/sway-lsp/src/capabilities/formatting.rs
+++ b/sway-lsp/src/capabilities/formatting.rs
@@ -7,6 +7,7 @@ use std::sync::Arc;
 use swayfmt::Formatter;
 
 pub fn format_text(documents: &Documents, url: &Url) -> Result<Vec<TextEdit>, LanguageServerError> {
+    let _p = tracing::trace_span!("format_text").entered();
     let document = documents.try_get(url.path()).try_unwrap().ok_or_else(|| {
         DocumentError::DocumentNotFound {
             path: url.path().to_string(),
diff --git a/sway-lsp/src/capabilities/highlight.rs b/sway-lsp/src/capabilities/highlight.rs
index f6eef7f4fb3..7236bb8a7e7 100644
--- a/sway-lsp/src/capabilities/highlight.rs
+++ b/sway-lsp/src/capabilities/highlight.rs
@@ -7,6 +7,7 @@ pub fn get_highlights(
     url: &Url,
     position: Position,
 ) -> Option<Vec<DocumentHighlight>> {
+    let _p = tracing::trace_span!("get_highlights").entered();
     session.token_ranges(url, position).map(|ranges| {
         ranges
             .into_iter()
diff --git a/sway-lsp/src/capabilities/hover/hover_link_contents.rs b/sway-lsp/src/capabilities/hover/hover_link_contents.rs
index f0dc74f8c39..6893eb35c2d 100644
--- a/sway-lsp/src/capabilities/hover/hover_link_contents.rs
+++ b/sway-lsp/src/capabilities/hover/hover_link_contents.rs
@@ -13,7 +13,7 @@ use sway_core::{
 };
 
 use lsp_types::{Range, Url};
-use sway_types::{Span, Spanned};
+use sway_types::{Named, Span, Spanned};
 
 #[derive(Debug, Clone)]
 pub struct RelatedType {
@@ -45,10 +45,10 @@ impl<'a> HoverLinkContents<'a> {
     pub fn add_related_types(&mut self, type_id: &TypeId) {
         let type_info = self.engines.te().get(*type_id);
         match &*type_info {
-            TypeInfo::Enum(decl_ref) => {
-                let decl = self.engines.de().get_enum(decl_ref);
+            TypeInfo::Enum(decl_id) => {
+                let decl = self.engines.de().get_enum(decl_id);
                 self.add_related_type(
-                    decl_ref.name().to_string(),
+                    decl.name().to_string(),
                     &decl.span(),
                     decl.call_path.clone(),
                 );
@@ -56,10 +56,10 @@ impl<'a> HoverLinkContents<'a> {
                     .iter()
                     .for_each(|type_param| self.add_related_types(&type_param.type_id));
             }
-            TypeInfo::Struct(decl_ref) => {
-                let decl = self.engines.de().get_struct(decl_ref);
+            TypeInfo::Struct(decl_id) => {
+                let decl = self.engines.de().get_struct(decl_id);
                 self.add_related_type(
-                    decl_ref.name().to_string(),
+                    decl.name().to_string(),
                     &decl.span(),
                     decl.call_path.clone(),
                 );
diff --git a/sway-lsp/src/capabilities/hover/mod.rs b/sway-lsp/src/capabilities/hover/mod.rs
index 26c7a5e0172..97ef886daf7 100644
--- a/sway-lsp/src/capabilities/hover/mod.rs
+++ b/sway-lsp/src/capabilities/hover/mod.rs
@@ -1,5 +1,7 @@
 pub(crate) mod hover_link_contents;
 
+use self::hover_link_contents::HoverLinkContents;
+use crate::config::LspClient;
 use crate::{
     core::{
         session::Session,
@@ -9,23 +11,21 @@ use crate::{
         attributes::doc_comment_attributes, keyword_docs::KeywordDocs, markdown, markup::Markup,
     },
 };
+use lsp_types::{self, Position, Url};
 use std::sync::Arc;
 use sway_core::{
     language::{ty, Visibility},
     Engines, TypeId,
 };
-
-use lsp_types::{self, Position, Url};
 use sway_types::{Span, Spanned};
 
-use self::hover_link_contents::HoverLinkContents;
-
 /// Extracts the hover information for a token at the current position.
 pub fn hover_data(
     session: Arc<Session>,
     keyword_docs: &KeywordDocs,
     url: &Url,
     position: Position,
+    client_config: LspClient,
 ) -> Option<lsp_types::Hover> {
     let t = session.token_map().token_at_position(url, position)?;
     let (ident, token) = t.pair();
@@ -60,11 +60,18 @@ pub fn hover_data(
                 &session.engines.read(),
                 decl_token,
                 &decl_ident.name,
+                client_config.clone(),
             )
         }
         // The `TypeInfo` of the token does not contain an `Ident`. In this case,
         // we use the `Ident` of the token itself.
-        None => hover_format(session.clone(), &session.engines.read(), token, &ident.name),
+        None => hover_format(
+            session.clone(),
+            &session.engines.read(),
+            token,
+            &ident.name,
+            client_config.clone(),
+        ),
     };
 
     Some(lsp_types::Hover {
@@ -122,6 +129,7 @@ fn hover_format(
     engines: &Engines,
     token: &Token,
     ident_name: &str,
+    client_config: LspClient,
 ) -> lsp_types::HoverContents {
     let decl_engine = engines.de();
     let doc_comment = format_doc_attributes(engines, token);
@@ -219,6 +227,7 @@ fn hover_format(
             engines.se(),
             &hover_link_contents.related_types,
             &hover_link_contents.implementations,
+            client_config,
         );
 
     lsp_types::HoverContents::Markup(markup_content(&content))
diff --git a/sway-lsp/src/capabilities/inlay_hints.rs b/sway-lsp/src/capabilities/inlay_hints.rs
index b95f3455312..a832948fc96 100644
--- a/sway-lsp/src/capabilities/inlay_hints.rs
+++ b/sway-lsp/src/capabilities/inlay_hints.rs
@@ -7,13 +7,16 @@ use crate::{
 };
 use lsp_types::{self, Range, Url};
 use std::sync::Arc;
-use sway_core::{language::ty::TyDecl, type_system::TypeInfo};
-use sway_types::Spanned;
+use sway_core::{
+    language::ty::{TyDecl, TyExpression, TyExpressionVariant},
+    type_system::TypeInfo,
+};
+use sway_types::{Ident, Spanned};
 
-// Future PR's will add more kinds
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum InlayKind {
     TypeHint,
+    Parameter,
 }
 
 #[derive(Debug)]
@@ -23,21 +26,27 @@ pub struct InlayHint {
     pub label: String,
 }
 
+/// Generates inlay hints for the provided range.
 pub fn inlay_hints(
     session: Arc<Session>,
     uri: &Url,
     range: &Range,
     config: &InlayHintsConfig,
 ) -> Option<Vec<lsp_types::InlayHint>> {
-    // 1. Loop through all our tokens and filter out all tokens that aren't TypedVariableDeclaration tokens
-    // 2. Also filter out all tokens that have a span that fall outside of the provided range
-    // 3. Filter out all variable tokens that have a type_ascription
-    // 4. Look up the type id for the remaining tokens
-    // 5. Convert the type into a string
+    let _span = tracing::trace_span!("inlay_hints").entered();
+
     if !config.type_hints {
         return None;
     }
 
+    // 1. Iterate through all tokens in the file
+    // 2. Filter for TypedVariableDeclaration tokens within the provided range
+    // 3. For each variable declaration:
+    //    a. If it's a function application, generate parameter hints
+    //    b. If it doesn't have a type ascription and its type is known:
+    //       - Look up the type information
+    //       - Generate a type hint
+    // 4. Collect all generated hints into a single vector
     let hints: Vec<lsp_types::InlayHint> = session
         .token_map()
         .tokens_for_file(uri)
@@ -45,58 +54,126 @@ pub fn inlay_hints(
             let token = item.value();
             token.typed.as_ref().and_then(|t| match t {
                 TypedAstToken::TypedDeclaration(TyDecl::VariableDecl(var_decl)) => {
-                    if var_decl.type_ascription.call_path_tree.is_some() {
-                        None
+                    let var_range = get_range_from_span(&var_decl.name.span());
+                    if var_range.start >= range.start && var_range.end <= range.end {
+                        Some(var_decl.clone())
                     } else {
-                        let var_range = get_range_from_span(&var_decl.name.span());
-                        if var_range.start >= range.start && var_range.end <= range.end {
-                            Some(var_decl.clone())
-                        } else {
-                            None
-                        }
+                        None
                     }
                 }
                 _ => None,
             })
         })
-        .filter_map(|var| {
-            let type_info = session.engines.read().te().get(var.type_ascription.type_id);
-            match &*type_info {
-                TypeInfo::Unknown | TypeInfo::UnknownGeneric { .. } => None,
-                _ => Some(var),
+        .flat_map(|var| {
+            let mut hints = Vec::new();
+
+            // Function parameter hints
+            if let TyExpressionVariant::FunctionApplication { arguments, .. } = &var.body.expression
+            {
+                hints.extend(handle_function_parameters(arguments, config));
             }
-        })
-        .map(|var| {
-            let range = get_range_from_span(&var.name.span());
-            let kind = InlayKind::TypeHint;
-            let label = format!("{}", session.engines.read().help_out(var.type_ascription));
-            let inlay_hint = InlayHint { range, kind, label };
-            self::inlay_hint(config.render_colons, inlay_hint)
+
+            // Variable declaration hints
+            if var.type_ascription.call_path_tree.is_none() {
+                let type_info = session.engines.read().te().get(var.type_ascription.type_id);
+                if !matches!(
+                    *type_info,
+                    TypeInfo::Unknown | TypeInfo::UnknownGeneric { .. }
+                ) {
+                    let range = get_range_from_span(&var.name.span());
+                    let kind = InlayKind::TypeHint;
+                    let label = format!("{}", session.engines.read().help_out(var.type_ascription));
+                    let inlay_hint = InlayHint { range, kind, label };
+                    hints.push(self::inlay_hint(config, inlay_hint));
+                }
+            }
+            hints
         })
         .collect();
 
     Some(hints)
 }
 
-fn inlay_hint(render_colons: bool, inlay_hint: InlayHint) -> lsp_types::InlayHint {
+fn handle_function_parameters(
+    arguments: &[(Ident, TyExpression)],
+    config: &InlayHintsConfig,
+) -> Vec<lsp_types::InlayHint> {
+    arguments
+        .iter()
+        .flat_map(|(name, exp)| {
+            let mut hints = Vec::new();
+            let (should_create_hint, span) = match &exp.expression {
+                TyExpressionVariant::Literal(_)
+                | TyExpressionVariant::ConstantExpression { .. }
+                | TyExpressionVariant::Tuple { .. }
+                | TyExpressionVariant::Array { .. }
+                | TyExpressionVariant::ArrayIndex { .. }
+                | TyExpressionVariant::FunctionApplication { .. }
+                | TyExpressionVariant::StructFieldAccess { .. }
+                | TyExpressionVariant::TupleElemAccess { .. } => (true, &exp.span),
+                TyExpressionVariant::EnumInstantiation {
+                    call_path_binding, ..
+                } => (true, &call_path_binding.span),
+                _ => (false, &exp.span),
+            };
+            if should_create_hint {
+                let range = get_range_from_span(span);
+                let kind = InlayKind::Parameter;
+                let label = name.as_str().to_string();
+                let inlay_hint = InlayHint { range, kind, label };
+                hints.push(self::inlay_hint(config, inlay_hint));
+            }
+            // Handle nested function applications
+            if let TyExpressionVariant::FunctionApplication {
+                arguments: nested_args,
+                ..
+            } = &exp.expression
+            {
+                hints.extend(handle_function_parameters(nested_args, config));
+            }
+            hints
+        })
+        .collect::<Vec<_>>()
+}
+
+fn inlay_hint(config: &InlayHintsConfig, inlay_hint: InlayHint) -> lsp_types::InlayHint {
+    let truncate_label = |label: String| -> String {
+        if let Some(max_length) = config.max_length {
+            if label.len() > max_length {
+                format!("{}...", &label[..max_length.saturating_sub(3)])
+            } else {
+                label
+            }
+        } else {
+            label
+        }
+    };
+
+    let label = match inlay_hint.kind {
+        InlayKind::TypeHint if config.render_colons => format!(": {}", inlay_hint.label),
+        InlayKind::Parameter if config.render_colons => format!("{}: ", inlay_hint.label),
+        _ => inlay_hint.label,
+    };
+
     lsp_types::InlayHint {
         position: match inlay_hint.kind {
             // after annotated thing
             InlayKind::TypeHint => inlay_hint.range.end,
+            InlayKind::Parameter => inlay_hint.range.start,
         },
-        label: lsp_types::InlayHintLabel::String(match inlay_hint.kind {
-            InlayKind::TypeHint if render_colons => format!(": {}", inlay_hint.label),
-            InlayKind::TypeHint => inlay_hint.label,
-        }),
+        label: lsp_types::InlayHintLabel::String(truncate_label(label)),
         kind: match inlay_hint.kind {
             InlayKind::TypeHint => Some(lsp_types::InlayHintKind::TYPE),
+            InlayKind::Parameter => Some(lsp_types::InlayHintKind::PARAMETER),
         },
         tooltip: None,
         padding_left: Some(match inlay_hint.kind {
-            InlayKind::TypeHint => !render_colons,
+            InlayKind::TypeHint => !config.render_colons,
+            InlayKind::Parameter => false,
         }),
         padding_right: Some(match inlay_hint.kind {
             InlayKind::TypeHint => false,
+            InlayKind::Parameter => !config.render_colons,
         }),
         text_edits: None,
         data: None,
diff --git a/sway-lsp/src/capabilities/rename.rs b/sway-lsp/src/capabilities/rename.rs
index a0eb011c948..6070fd992c9 100644
--- a/sway-lsp/src/capabilities/rename.rs
+++ b/sway-lsp/src/capabilities/rename.rs
@@ -20,6 +20,7 @@ pub fn rename(
     url: &Url,
     position: Position,
 ) -> Result<WorkspaceEdit, LanguageServerError> {
+    let _p = tracing::trace_span!("rename").entered();
     // Make sure the new name is not a keyword or a literal int type
     if sway_parse::RESERVED_KEYWORDS.contains(&new_name)
         || sway_parse::parse_int_suffix(&new_name).is_some()
@@ -217,8 +218,8 @@ fn find_all_methods_for_decl<'a>(
                             engines.se(),
                         ))
                     }
-                    ty::TyDecl::ImplTrait(ty::ImplTrait { decl_id, .. }) => {
-                        let impl_trait = engines.de().get_impl_trait(decl_id);
+                    ty::TyDecl::ImplSelfOrTrait(ty::ImplSelfOrTrait { decl_id, .. }) => {
+                        let impl_trait = engines.de().get_impl_self_or_trait(decl_id);
                         Some(
                             impl_trait
                                 .items
diff --git a/sway-lsp/src/capabilities/semantic_tokens.rs b/sway-lsp/src/capabilities/semantic_tokens.rs
index 05cd9e41474..30b2fc16564 100644
--- a/sway-lsp/src/capabilities/semantic_tokens.rs
+++ b/sway-lsp/src/capabilities/semantic_tokens.rs
@@ -27,6 +27,7 @@ pub fn semantic_tokens_range(
     url: &Url,
     range: &Range,
 ) -> Option<SemanticTokensRangeResult> {
+    let _p = tracing::trace_span!("semantic_tokens_range").entered();
     let tokens: Vec<_> = session
         .token_map()
         .tokens_for_file(url)
diff --git a/sway-lsp/src/config.rs b/sway-lsp/src/config.rs
index 0a3a5597462..528e4385510 100644
--- a/sway-lsp/src/config.rs
+++ b/sway-lsp/src/config.rs
@@ -4,6 +4,8 @@ use tracing::metadata::LevelFilter;
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct Config {
+    #[serde(default)]
+    pub client: LspClient,
     #[serde(default)]
     pub debug: DebugConfig,
     #[serde(default)]
@@ -20,6 +22,15 @@ pub struct Config {
     pub garbage_collection: GarbageCollectionConfig,
 }
 
+#[derive(Clone, Default, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum LspClient {
+    VsCode,
+    #[serde(other)]
+    #[default]
+    Other,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Default)]
 struct TraceConfig {}
 
@@ -60,17 +71,11 @@ impl Default for DiagnosticConfig {
 #[serde(rename_all = "camelCase")]
 pub struct GarbageCollectionConfig {
     pub gc_enabled: bool,
-    pub gc_frequency: i32,
 }
 
 impl Default for GarbageCollectionConfig {
     fn default() -> Self {
-        Self {
-            gc_enabled: true,
-            // Garbage collection is fairly expsensive so we default to only clear on every 3rd keystroke.
-            // Waiting too long to clear can cause a stack overflow to occur.
-            gc_frequency: 3,
-        }
+        Self { gc_enabled: true }
     }
 }
 
diff --git a/sway-lsp/src/core/document.rs b/sway-lsp/src/core/document.rs
index a5599190a67..c49f6750452 100644
--- a/sway-lsp/src/core/document.rs
+++ b/sway-lsp/src/core/document.rs
@@ -1,4 +1,5 @@
-#![allow(dead_code)]
+use std::sync::Arc;
+
 use crate::{
     error::{DirectoryError, DocumentError, LanguageServerError},
     utils::document,
@@ -6,138 +7,110 @@ use crate::{
 use dashmap::DashMap;
 use forc_util::fs_locking::PidFileLocking;
 use lsp_types::{Position, Range, TextDocumentContentChangeEvent, Url};
-use ropey::Rope;
 use tokio::{fs::File, io::AsyncWriteExt};
 
 #[derive(Debug, Clone)]
 pub struct TextDocument {
-    #[allow(dead_code)]
-    language_id: String,
-    #[allow(dead_code)]
     version: i32,
     uri: String,
-    content: Rope,
+    content: String,
+    line_offsets: Vec<usize>,
 }
 
 impl TextDocument {
     pub async fn build_from_path(path: &str) -> Result<Self, DocumentError> {
         tokio::fs::read_to_string(path)
             .await
-            .map(|content| Self {
-                language_id: "sway".into(),
-                version: 1,
-                uri: path.into(),
-                content: Rope::from_str(&content),
+            .map(|content| {
+                let line_offsets = TextDocument::calculate_line_offsets(&content);
+                Self {
+                    version: 1,
+                    uri: path.into(),
+                    content,
+                    line_offsets,
+                }
+            })
+            .map_err(|e| match e.kind() {
+                std::io::ErrorKind::NotFound => {
+                    DocumentError::DocumentNotFound { path: path.into() }
+                }
+                std::io::ErrorKind::PermissionDenied => {
+                    DocumentError::PermissionDenied { path: path.into() }
+                }
+                _ => DocumentError::IOError {
+                    path: path.into(),
+                    error: e.to_string(),
+                },
             })
-            .map_err(|_| DocumentError::DocumentNotFound { path: path.into() })
     }
 
     pub fn get_uri(&self) -> &str {
         &self.uri
     }
 
-    pub fn get_line(&self, line: usize) -> String {
-        self.content.line(line).to_string()
-    }
-
-    pub fn apply_change(&mut self, change: &TextDocumentContentChangeEvent) {
-        let edit = self.build_edit(change);
-
-        self.content.remove(edit.start_index..edit.end_index);
-        self.content.insert(edit.start_index, edit.change_text);
+    pub fn get_text(&self) -> &str {
+        &self.content
     }
 
-    pub fn get_text(&self) -> String {
-        self.content.to_string()
+    pub fn get_line(&self, line: usize) -> &str {
+        let start = self
+            .line_offsets
+            .get(line)
+            .copied()
+            .unwrap_or(self.content.len());
+        let end = self
+            .line_offsets
+            .get(line + 1)
+            .copied()
+            .unwrap_or(self.content.len());
+        &self.content[start..end]
     }
-}
 
-// private methods
-impl TextDocument {
-    fn build_edit<'change>(
-        &self,
-        change: &'change TextDocumentContentChangeEvent,
-    ) -> EditText<'change> {
-        let change_text = change.text.as_str();
-        let text_bytes = change_text.as_bytes();
-        let text_end_byte_index = text_bytes.len();
-
-        let range = if let Some(range) = change.range {
-            range
+    pub fn apply_change(
+        &mut self,
+        change: &TextDocumentContentChangeEvent,
+    ) -> Result<(), DocumentError> {
+        if let Some(range) = change.range {
+            self.validate_range(range)?;
+            let start_index = self.position_to_index(range.start);
+            let end_index = self.position_to_index(range.end);
+            self.content
+                .replace_range(start_index..end_index, &change.text);
         } else {
-            let start = self.byte_to_position(0);
-            let end = self.byte_to_position(text_end_byte_index);
-            Range { start, end }
-        };
-
-        let start_index = self.position_to_index(range.start);
-        let end_index = self.position_to_index(range.end);
-
-        EditText {
-            start_index,
-            end_index,
-            change_text,
+            self.content.clone_from(&change.text);
         }
+        self.line_offsets = Self::calculate_line_offsets(&self.content);
+        self.version += 1;
+        Ok(())
     }
 
-    fn byte_to_position(&self, byte_index: usize) -> Position {
-        let line_index = self.content.byte_to_line(byte_index);
-
-        let line_utf16_cu_index = {
-            let char_index = self.content.line_to_char(line_index);
-            self.content.char_to_utf16_cu(char_index)
-        };
-
-        let character_utf16_cu_index = {
-            let char_index = self.content.byte_to_char(byte_index);
-            self.content.char_to_utf16_cu(char_index)
-        };
-
-        let character = character_utf16_cu_index - line_utf16_cu_index;
-
-        Position::new(line_index as u32, character as u32)
+    fn validate_range(&self, range: Range) -> Result<(), DocumentError> {
+        let start = self.position_to_index(range.start);
+        let end = self.position_to_index(range.end);
+        if start > end || end > self.content.len() {
+            return Err(DocumentError::InvalidRange { range });
+        }
+        Ok(())
     }
 
     fn position_to_index(&self, position: Position) -> usize {
-        let row_index = position.line as usize;
-        let column_index = position.character as usize;
-
-        let row_char_index = self.content.line_to_char(row_index);
-        let column_char_index = self.content.utf16_cu_to_char(column_index);
-
-        row_char_index + column_char_index
+        let line_offset = self
+            .line_offsets
+            .get(position.line as usize)
+            .copied()
+            .unwrap_or(self.content.len());
+        line_offset + position.character as usize
     }
-}
-
-/// Marks the specified file as "dirty" by creating a corresponding flag file.
-///
-/// This function ensures the necessary directory structure exists before creating the flag file.
-pub fn mark_file_as_dirty(uri: &Url) -> Result<(), LanguageServerError> {
-    let path = document::get_path_from_url(uri)?;
-    Ok(PidFileLocking::lsp(path)
-        .lock()
-        .map_err(|e| DirectoryError::LspLocksDirFailed(e.to_string()))?)
-}
-
-/// Removes the corresponding flag file for the specified Url.
-///
-/// If the flag file does not exist, this function will do nothing.
-pub fn remove_dirty_flag(uri: &Url) -> Result<(), LanguageServerError> {
-    let path = document::get_path_from_url(uri)?;
-    let uri = uri.clone();
-    Ok(PidFileLocking::lsp(path)
-        .release()
-        .map_err(|err| DocumentError::UnableToRemoveFile {
-            path: uri.path().to_string(),
-            err: err.to_string(),
-        })?)
-}
 
-#[derive(Debug)]
-struct EditText<'text> {
-    start_index: usize,
-    end_index: usize,
-    change_text: &'text str,
+    fn calculate_line_offsets(text: &str) -> Vec<usize> {
+        let mut offsets = vec![0];
+        for (i, c) in text.char_indices() {
+            if c == '\n' {
+                offsets.push(i + 1);
+            }
+        }
+        offsets
+    }
 }
 
 pub struct Documents(DashMap<String, TextDocument>);
@@ -167,11 +140,7 @@ impl Documents {
         uri: &Url,
         changes: &[TextDocumentContentChangeEvent],
     ) -> Result<(), LanguageServerError> {
-        let src = self.update_text_document(uri, changes).ok_or_else(|| {
-            DocumentError::DocumentNotFound {
-                path: uri.path().to_string(),
-            }
-        })?;
+        let src = self.update_text_document(uri, changes)?;
 
         let mut file =
             File::create(uri.path())
@@ -191,32 +160,35 @@ impl Documents {
         Ok(())
     }
 
-    /// Get the document at the given [Url].
-    pub fn get_text_document(&self, url: &Url) -> Result<TextDocument, DocumentError> {
-        self.try_get(url.path())
-            .try_unwrap()
-            .ok_or_else(|| DocumentError::DocumentNotFound {
-                path: url.path().to_string(),
-            })
-            .map(|document| document.clone())
-    }
-
     /// Update the document at the given [Url] with the Vec of changes returned by the client.
     pub fn update_text_document(
         &self,
-        url: &Url,
+        uri: &Url,
         changes: &[TextDocumentContentChangeEvent],
-    ) -> Option<String> {
-        self.try_get_mut(url.path())
+    ) -> Result<String, DocumentError> {
+        self.try_get_mut(uri.path())
             .try_unwrap()
-            .map(|mut document| {
+            .ok_or_else(|| DocumentError::DocumentNotFound {
+                path: uri.path().to_string(),
+            })
+            .and_then(|mut document| {
                 for change in changes {
-                    document.apply_change(change);
+                    document.apply_change(change)?;
                 }
-                document.get_text()
+                Ok(document.get_text().to_string())
             })
     }
 
+    /// Get the document at the given [Url].
+    pub fn get_text_document(&self, url: &Url) -> Result<TextDocument, DocumentError> {
+        self.try_get(url.path())
+            .try_unwrap()
+            .ok_or_else(|| DocumentError::DocumentNotFound {
+                path: url.path().to_string(),
+            })
+            .map(|document| document.clone())
+    }
+
     /// Remove the text document.
     pub fn remove_document(&self, url: &Url) -> Result<TextDocument, DocumentError> {
         self.remove(url.path())
@@ -242,6 +214,57 @@ impl std::ops::Deref for Documents {
     }
 }
 
+/// Manages process-based file locking for multiple files.
+pub struct PidLockedFiles {
+    locks: DashMap<Url, Arc<PidFileLocking>>,
+}
+
+impl Default for PidLockedFiles {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PidLockedFiles {
+    pub fn new() -> Self {
+        Self {
+            locks: DashMap::new(),
+        }
+    }
+
+    /// Marks the specified file as "dirty" by creating a corresponding flag file.
+    ///
+    /// This function ensures the necessary directory structure exists before creating the flag file.
+    /// If the file is already locked, this function will do nothing. This is to reduce the number of
+    /// unnecessary file IO operations.
+    pub fn mark_file_as_dirty(&self, uri: &Url) -> Result<(), LanguageServerError> {
+        if !self.locks.contains_key(uri) {
+            let path = document::get_path_from_url(uri)?;
+            let file_lock = Arc::new(PidFileLocking::lsp(path));
+            file_lock
+                .lock()
+                .map_err(|e| DirectoryError::LspLocksDirFailed(e.to_string()))?;
+            self.locks.insert(uri.clone(), file_lock);
+        }
+        Ok(())
+    }
+
+    /// Removes the corresponding flag file for the specified Url.
+    ///
+    /// If the flag file does not exist, this function will do nothing.
+    pub fn remove_dirty_flag(&self, uri: &Url) -> Result<(), LanguageServerError> {
+        if let Some((uri, file_lock)) = self.locks.remove(uri) {
+            file_lock
+                .release()
+                .map_err(|err| DocumentError::UnableToRemoveFile {
+                    path: uri.path().to_string(),
+                    err: err.to_string(),
+                })?;
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -252,6 +275,11 @@ mod tests {
         let path = get_absolute_path("sway-lsp/tests/fixtures/cats.txt");
         let result = TextDocument::build_from_path(&path).await;
         assert!(result.is_ok(), "result = {result:?}");
+        let document = result.unwrap();
+        assert_eq!(document.version, 1);
+        assert_eq!(document.uri, path);
+        assert!(!document.content.is_empty());
+        assert!(!document.line_offsets.is_empty());
     }
 
     #[tokio::test]
@@ -286,4 +314,51 @@ mod tests {
             .expect_err("expected DocumentAlreadyStored");
         assert_eq!(result, DocumentError::DocumentAlreadyStored { path });
     }
+
+    #[test]
+    fn get_line_returns_correct_line() {
+        let content = "line1\nline2\nline3".to_string();
+        let line_offsets = TextDocument::calculate_line_offsets(&content);
+        let document = TextDocument {
+            version: 1,
+            uri: "test.sw".into(),
+            content,
+            line_offsets,
+        };
+        assert_eq!(document.get_line(0), "line1\n");
+        assert_eq!(document.get_line(1), "line2\n");
+        assert_eq!(document.get_line(2), "line3");
+    }
+
+    #[test]
+    fn apply_change_updates_content_correctly() {
+        let content = "Hello, world!".to_string();
+        let line_offsets = TextDocument::calculate_line_offsets(&content);
+        let mut document = TextDocument {
+            version: 1,
+            uri: "test.sw".into(),
+            content,
+            line_offsets,
+        };
+        let change = TextDocumentContentChangeEvent {
+            range: Some(Range::new(Position::new(0, 7), Position::new(0, 12))),
+            range_length: None,
+            text: "Rust".into(),
+        };
+        document.apply_change(&change).unwrap();
+        assert_eq!(document.get_text(), "Hello, Rust!");
+    }
+
+    #[test]
+    fn position_to_index_works_correctly() {
+        let content = "line1\nline2\nline3".to_string();
+        let line_offsets = TextDocument::calculate_line_offsets(&content);
+        let document = TextDocument {
+            version: 1,
+            uri: "test.sw".into(),
+            content,
+            line_offsets,
+        };
+        assert_eq!(document.position_to_index(Position::new(1, 2)), 8);
+    }
 }
diff --git a/sway-lsp/src/core/session.rs b/sway-lsp/src/core/session.rs
index 749168d1538..c55869d5f66 100644
--- a/sway-lsp/src/core/session.rs
+++ b/sway-lsp/src/core/session.rs
@@ -12,7 +12,8 @@ use crate::{
     },
     error::{DirectoryError, DocumentError, LanguageServerError},
     traverse::{
-        dependency, lexed_tree, parsed_tree::ParsedTree, typed_tree::TypedTree, ParseContext,
+        dependency, lexed_tree::LexedTree, parsed_tree::ParsedTree, typed_tree::TypedTree,
+        ParseContext,
     },
 };
 use dashmap::DashMap;
@@ -29,7 +30,9 @@ use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use std::{
     path::PathBuf,
     sync::{atomic::AtomicBool, Arc},
+    time::SystemTime,
 };
+use sway_ast::{attribute::Annotated, ItemKind};
 use sway_core::{
     decl_engine::DeclEngine,
     language::{
@@ -61,6 +64,7 @@ pub struct CompiledProgram {
 pub struct Session {
     token_map: TokenMap,
     pub runnables: RunnableMap,
+    pub build_plan_cache: BuildPlanCache,
     pub compiled_program: RwLock<CompiledProgram>,
     pub engines: RwLock<Engines>,
     pub sync: SyncWorkspace,
@@ -80,6 +84,7 @@ impl Session {
         Session {
             token_map: TokenMap::new(),
             runnables: DashMap::new(),
+            build_plan_cache: BuildPlanCache::default(),
             metrics: DashMap::new(),
             compiled_program: RwLock::new(CompiledProgram::default()),
             engines: <_>::default(),
@@ -121,7 +126,11 @@ impl Session {
     }
 
     /// Clean up memory in the [TypeEngine] and [DeclEngine] for the user's workspace.
-    pub fn garbage_collect(&self, engines: &mut Engines) -> Result<(), LanguageServerError> {
+    pub fn garbage_collect_program(
+        &self,
+        engines: &mut Engines,
+    ) -> Result<(), LanguageServerError> {
+        let _p = tracing::trace_span!("garbage_collect").entered();
         let path = self.sync.temp_dir()?;
         let program_id = { engines.se().get_program_id(&path) };
         if let Some(program_id) = program_id {
@@ -130,7 +139,40 @@ impl Session {
         Ok(())
     }
 
+    /// Clean up memory in the [TypeEngine] and [DeclEngine] for the modified file.
+    pub fn garbage_collect_module(
+        &self,
+        engines: &mut Engines,
+        uri: &Url,
+    ) -> Result<(), LanguageServerError> {
+        let path = uri.to_file_path().unwrap();
+        let source_id = { engines.se().get_source_id(&path) };
+        engines.clear_module(&source_id);
+        Ok(())
+    }
+
+    pub fn token_references(&self, url: &Url, position: Position) -> Option<Vec<Location>> {
+        let _p = tracing::trace_span!("token_references").entered();
+        let token_references: Vec<_> = self
+            .token_map
+            .iter()
+            .all_references_of_token(
+                self.token_map.token_at_position(url, position)?.value(),
+                &self.engines.read(),
+            )
+            .filter_map(|item| {
+                let path = item.key().path.as_ref()?;
+                let uri = Url::from_file_path(path).ok()?;
+                self.sync
+                    .to_workspace_url(uri)
+                    .map(|workspace_url| Location::new(workspace_url, item.key().range))
+            })
+            .collect();
+        Some(token_references)
+    }
+
     pub fn token_ranges(&self, url: &Url, position: Position) -> Option<Vec<Range>> {
+        let _p = tracing::trace_span!("token_ranges").entered();
         let mut token_ranges: Vec<_> = self
             .token_map
             .tokens_for_file(url)
@@ -150,6 +192,7 @@ impl Session {
         uri: &Url,
         position: Position,
     ) -> Option<GotoDefinitionResponse> {
+        let _p = tracing::trace_span!("token_definition_response").entered();
         self.token_map
             .token_at_position(uri, position)
             .and_then(|item| item.value().declared_token_ident(&self.engines.read()))
@@ -171,6 +214,7 @@ impl Session {
         position: Position,
         trigger_char: &str,
     ) -> Option<Vec<CompletionItem>> {
+        let _p = tracing::trace_span!("completion_items").entered();
         let shifted_position = Position {
             line: position.line,
             character: position.character - trigger_char.len() as u32 - 1,
@@ -205,6 +249,7 @@ impl Session {
     }
 
     pub fn symbol_information(&self, url: &Url) -> Option<Vec<SymbolInformation>> {
+        let _p = tracing::trace_span!("symbol_information").entered();
         let tokens = self.token_map.tokens_for_file(url);
         self.sync
             .to_workspace_url(url.clone())
@@ -223,7 +268,8 @@ impl Session {
 }
 
 /// Create a [BuildPlan] from the given [Url] appropriate for the language server.
-pub(crate) fn build_plan(uri: &Url) -> Result<BuildPlan, LanguageServerError> {
+pub fn build_plan(uri: &Url) -> Result<BuildPlan, LanguageServerError> {
+    let _p = tracing::trace_span!("build_plan").entered();
     let manifest_dir = PathBuf::from(uri.path());
     let manifest =
         ManifestFile::from_dir(manifest_dir).map_err(|_| DocumentError::ManifestFileNotFound {
@@ -248,20 +294,19 @@ pub(crate) fn build_plan(uri: &Url) -> Result<BuildPlan, LanguageServerError> {
 }
 
 pub fn compile(
-    uri: &Url,
+    build_plan: &BuildPlan,
     engines: &Engines,
     retrigger_compilation: Option<Arc<AtomicBool>>,
-    lsp_mode: Option<LspConfig>,
+    lsp_mode: Option<&LspConfig>,
     experimental: sway_core::ExperimentalFlags,
 ) -> Result<Vec<(Option<Programs>, Handler)>, LanguageServerError> {
-    let build_plan = build_plan(uri)?;
-    let tests_enabled = true;
+    let _p = tracing::trace_span!("compile").entered();
     pkg::check(
-        &build_plan,
+        build_plan,
         BuildTarget::default(),
         true,
-        lsp_mode,
-        tests_enabled,
+        lsp_mode.cloned(),
+        true,
         engines,
         retrigger_compilation,
         experimental,
@@ -275,8 +320,20 @@ pub fn traverse(
     results: Vec<(Option<Programs>, Handler)>,
     engines_clone: &Engines,
     session: Arc<Session>,
+    lsp_mode: Option<&LspConfig>,
 ) -> Result<Option<CompileResults>, LanguageServerError> {
-    session.token_map.clear();
+    let _p = tracing::trace_span!("traverse").entered();
+    let modified_file = lsp_mode.and_then(|mode| {
+        mode.file_versions
+            .iter()
+            .find_map(|(path, version)| version.map(|_| path.clone()))
+    });
+    if let Some(path) = &modified_file {
+        session.token_map.remove_tokens_for_file(path);
+    } else {
+        session.token_map.clear();
+    }
+
     session.metrics.clear();
     let mut diagnostics: CompileResults = (Vec::default(), Vec::default());
     let results_len = results.len();
@@ -313,6 +370,14 @@ pub fn traverse(
             let path = engines.se().get_path(source_id);
             let program_id = program_id_from_path(&path, engines)?;
             session.metrics.insert(program_id, metrics);
+
+            if let Some(modified_file) = &modified_file {
+                let modified_program_id = program_id_from_path(modified_file, engines)?;
+                // We can skip traversing the programs for this iteration as they are unchanged.
+                if program_id != modified_program_id {
+                    continue;
+                }
+            }
         }
 
         // Get a reference to the typed program AST.
@@ -332,17 +397,23 @@ pub fn traverse(
         // The final element in the results is the main program.
         if i == results_len - 1 {
             // First, populate our token_map with sway keywords.
-            lexed_tree::parse(&lexed, &ctx);
+            let lexed_tree = LexedTree::new(&ctx);
+            lexed_tree.collect_module_kinds(&lexed);
+            parse_lexed_program(&lexed, &ctx, &modified_file, |an, _ctx| {
+                lexed_tree.traverse_node(an)
+            });
 
             // Next, populate our token_map with un-typed yet parsed ast nodes.
             let parsed_tree = ParsedTree::new(&ctx);
             parsed_tree.collect_module_spans(&parsed);
-            parse_ast_to_tokens(&parsed, &ctx, |an, _ctx| parsed_tree.traverse_node(an));
+            parse_ast_to_tokens(&parsed, &ctx, &modified_file, |an, _ctx| {
+                parsed_tree.traverse_node(an)
+            });
 
             // Finally, populate our token_map with typed ast nodes.
             let typed_tree = TypedTree::new(&ctx);
             typed_tree.collect_module_spans(typed_program);
-            parse_ast_to_typed_tokens(typed_program, &ctx, |node, _ctx| {
+            parse_ast_to_typed_tokens(typed_program, &ctx, &modified_file, |node, _ctx| {
                 typed_tree.traverse_node(node);
             });
 
@@ -352,11 +423,11 @@ pub fn traverse(
             compiled_program.typed = Some(typed_program.clone());
         } else {
             // Collect tokens from dependencies and the standard library prelude.
-            parse_ast_to_tokens(&parsed, &ctx, |an, ctx| {
+            parse_ast_to_tokens(&parsed, &ctx, &modified_file, |an, ctx| {
                 dependency::collect_parsed_declaration(an, ctx);
             });
 
-            parse_ast_to_typed_tokens(typed_program, &ctx, |node, ctx| {
+            parse_ast_to_typed_tokens(typed_program, &ctx, &modified_file, |node, ctx| {
                 dependency::collect_typed_declaration(node, ctx);
             });
         }
@@ -373,17 +444,27 @@ pub fn parse_project(
     session: Arc<Session>,
     experimental: sway_core::ExperimentalFlags,
 ) -> Result<(), LanguageServerError> {
+    let _p = tracing::trace_span!("parse_project").entered();
+    let build_plan = session
+        .build_plan_cache
+        .get_or_update(&session.sync.manifest_path(), || build_plan(uri))?;
+
     let results = compile(
-        uri,
+        &build_plan,
         engines,
         retrigger_compilation,
-        lsp_mode.clone(),
+        lsp_mode.as_ref(),
         experimental,
     )?;
-    if results.last().is_none() {
+
+    // Check if the last result is None or if results is empty, indicating an error occurred in the compiler.
+    // If we don't return an error here, then we will likely crash when trying to access the Engines
+    // during traversal or when creating runnables.
+    if results.last().map_or(true, |(value, _)| value.is_none()) {
         return Err(LanguageServerError::ProgramsIsNone);
     }
-    let diagnostics = traverse(results, engines, session.clone())?;
+
+    let diagnostics = traverse(results, engines, session.clone(), lsp_mode.as_ref())?;
     if let Some(config) = &lsp_mode {
         // Only write the diagnostics results on didSave or didOpen.
         if !config.optimized_build {
@@ -393,20 +474,79 @@ pub fn parse_project(
             }
         }
     }
+
     if let Some(typed) = &session.compiled_program.read().typed {
         session.runnables.clear();
-        create_runnables(&session.runnables, typed, engines.de(), engines.se());
+        let path = uri.to_file_path().unwrap();
+        let program_id = program_id_from_path(&path, engines)?;
+        if let Some(metrics) = session.metrics.get(&program_id) {
+            // Check if the cached AST was returned by the compiler for the users workspace.
+            // If it was, then we need to use the original engines.
+            let engines = if metrics.reused_programs > 0 {
+                &*session.engines.read()
+            } else {
+                engines
+            };
+            create_runnables(&session.runnables, typed, engines.de(), engines.se());
+        }
     }
     Ok(())
 }
 
+/// Parse the [LexedProgram] to populate the [TokenMap] with lexed nodes.
+pub fn parse_lexed_program(
+    lexed_program: &LexedProgram,
+    ctx: &ParseContext,
+    modified_file: &Option<PathBuf>,
+    f: impl Fn(&Annotated<ItemKind>, &ParseContext) + Sync,
+) {
+    let should_process = |item: &&Annotated<ItemKind>| {
+        modified_file
+            .as_ref()
+            .map(|path| {
+                item.span()
+                    .source_id()
+                    .map_or(false, |id| ctx.engines.se().get_path(id) == *path)
+            })
+            .unwrap_or(true)
+    };
+
+    lexed_program
+        .root
+        .tree
+        .items
+        .iter()
+        .chain(
+            lexed_program
+                .root
+                .submodules_recursive()
+                .flat_map(|(_, submodule)| &submodule.module.tree.items),
+        )
+        .filter(should_process)
+        .collect::<Vec<_>>()
+        .par_iter()
+        .for_each(|item| f(item, ctx));
+}
+
 /// Parse the [ParseProgram] AST to populate the [TokenMap] with parsed AST nodes.
 fn parse_ast_to_tokens(
     parse_program: &ParseProgram,
     ctx: &ParseContext,
+    modified_file: &Option<PathBuf>,
     f: impl Fn(&AstNode, &ParseContext) + Sync,
 ) {
-    let nodes = parse_program
+    let should_process = |node: &&AstNode| {
+        modified_file
+            .as_ref()
+            .map(|path| {
+                node.span
+                    .source_id()
+                    .map_or(false, |id| ctx.engines.se().get_path(id) == *path)
+            })
+            .unwrap_or(true)
+    };
+
+    parse_program
         .root
         .tree
         .root_nodes
@@ -417,17 +557,31 @@ fn parse_ast_to_tokens(
                 .submodules_recursive()
                 .flat_map(|(_, submodule)| &submodule.module.tree.root_nodes),
         )
-        .collect::<Vec<_>>();
-    nodes.par_iter().for_each(|n| f(n, ctx));
+        .filter(should_process)
+        .collect::<Vec<_>>()
+        .par_iter()
+        .for_each(|n| f(n, ctx));
 }
 
 /// Parse the [ty::TyProgram] AST to populate the [TokenMap] with typed AST nodes.
 fn parse_ast_to_typed_tokens(
     typed_program: &ty::TyProgram,
     ctx: &ParseContext,
+    modified_file: &Option<PathBuf>,
     f: impl Fn(&ty::TyAstNode, &ParseContext) + Sync,
 ) {
-    let nodes = typed_program
+    let should_process = |node: &&ty::TyAstNode| {
+        modified_file
+            .as_ref()
+            .map(|path| {
+                node.span
+                    .source_id()
+                    .map_or(false, |id| ctx.engines.se().get_path(id) == *path)
+            })
+            .unwrap_or(true)
+    };
+
+    typed_program
         .root
         .all_nodes
         .iter()
@@ -437,8 +591,10 @@ fn parse_ast_to_typed_tokens(
                 .submodules_recursive()
                 .flat_map(|(_, submodule)| &submodule.module.all_nodes),
         )
-        .collect::<Vec<_>>();
-    nodes.par_iter().for_each(|n| f(n, ctx));
+        .filter(should_process)
+        .collect::<Vec<_>>()
+        .par_iter()
+        .for_each(|n| f(n, ctx));
 }
 
 /// Create runnables if the `TyProgramKind` of the `TyProgram` is a script.
@@ -448,7 +604,9 @@ fn create_runnables(
     decl_engine: &DeclEngine,
     source_engine: &SourceEngine,
 ) {
+    let _p = tracing::trace_span!("create_runnables").entered();
     // Insert runnable test functions.
+
     for (decl, _) in typed_program.test_fns(decl_engine) {
         // Get the span of the first attribute if it exists, otherwise use the span of the function name.
         let span = decl
@@ -465,7 +623,6 @@ fn create_runnables(
             runnables.entry(path).or_default().push(runnable);
         }
     }
-
     // Insert runnable main function if the program is a script.
     if let ty::TyProgramKind::Script {
         entry_function: ref main_function,
@@ -498,6 +655,56 @@ pub(crate) fn program_id_from_path(
     Ok(program_id)
 }
 
+/// A cache for storing and retrieving BuildPlan objects.
+#[derive(Debug, Clone)]
+pub struct BuildPlanCache {
+    /// The cached BuildPlan and its last update time
+    cache: Arc<RwLock<Option<(BuildPlan, SystemTime)>>>,
+}
+
+impl Default for BuildPlanCache {
+    fn default() -> Self {
+        Self {
+            cache: Arc::new(RwLock::new(None)),
+        }
+    }
+}
+
+impl BuildPlanCache {
+    /// Retrieves a BuildPlan from the cache or updates it if necessary.
+    pub fn get_or_update<F>(
+        &self,
+        manifest_path: &Option<PathBuf>,
+        update_fn: F,
+    ) -> Result<BuildPlan, LanguageServerError>
+    where
+        F: FnOnce() -> Result<BuildPlan, LanguageServerError>,
+    {
+        let should_update = {
+            let cache = self.cache.read();
+            manifest_path
+                .as_ref()
+                .and_then(|path| path.metadata().ok()?.modified().ok())
+                .map_or(cache.is_none(), |time| {
+                    cache.as_ref().map_or(true, |&(_, last)| time > last)
+                })
+        };
+
+        if should_update {
+            let new_plan = update_fn()?;
+            let mut cache = self.cache.write();
+            *cache = Some((new_plan.clone(), SystemTime::now()));
+            Ok(new_plan)
+        } else {
+            let cache = self.cache.read();
+            cache
+                .as_ref()
+                .map(|(plan, _)| plan.clone())
+                .ok_or(LanguageServerError::BuildPlanCacheIsEmpty)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/sway-lsp/src/core/sync.rs b/sway-lsp/src/core/sync.rs
index bf6c9fa73a7..8c405f5e801 100644
--- a/sway-lsp/src/core/sync.rs
+++ b/sway-lsp/src/core/sync.rs
@@ -175,7 +175,7 @@ impl SyncWorkspace {
             .ok()
     }
 
-    pub(crate) fn manifest_path(&self) -> Option<PathBuf> {
+    pub fn manifest_path(&self) -> Option<PathBuf> {
         self.manifest_dir()
             .map(|dir| dir.join(sway_utils::constants::MANIFEST_FILE_NAME))
             .ok()
@@ -194,13 +194,12 @@ impl SyncWorkspace {
                     let handle = tokio::spawn(async move {
                         let (tx, mut rx) = tokio::sync::mpsc::channel(10);
                         // Setup debouncer. No specific tickrate, max debounce time 2 seconds
-                        let mut debouncer =
-                            new_debouncer(Duration::from_secs(1), None, move |event| {
-                                if let Ok(e) = event {
-                                    let _ = tx.blocking_send(e);
-                                }
-                            })
-                            .unwrap();
+                        let mut debouncer = new_debouncer(Duration::from_secs(1), move |event| {
+                            if let Ok(e) = event {
+                                let _ = tx.blocking_send(e);
+                            }
+                        })
+                        .unwrap();
 
                         debouncer
                             .watcher()
@@ -286,7 +285,7 @@ pub(crate) fn edit_manifest_dependency_paths(
         if let Ok(mut file) = File::open(manifest.path()) {
             let mut toml = String::new();
             let _ = file.read_to_string(&mut toml);
-            if let Ok(mut manifest_toml) = toml.parse::<toml_edit::Document>() {
+            if let Ok(mut manifest_toml) = toml.parse::<toml_edit::DocumentMut>() {
                 for (name, abs_path) in dependency_map {
                     manifest_toml["dependencies"][&name]["path"] =
                         toml_edit::value(abs_path.display().to_string());
diff --git a/sway-lsp/src/core/token.rs b/sway-lsp/src/core/token.rs
index 51a84347d83..3e657a0cff9 100644
--- a/sway-lsp/src/core/token.rs
+++ b/sway-lsp/src/core/token.rs
@@ -285,6 +285,10 @@ pub fn type_info_to_symbol_kind(
             let type_info = type_engine.get(elem_ty.type_id);
             type_info_to_symbol_kind(type_engine, &type_info, Some(&elem_ty.span()))
         }
+        TypeInfo::Slice(elem_ty) => {
+            let type_info = type_engine.get(elem_ty.type_id);
+            type_info_to_symbol_kind(type_engine, &type_info, Some(&elem_ty.span()))
+        }
         _ => SymbolKind::Unknown,
     }
 }
diff --git a/sway-lsp/src/core/token_map.rs b/sway-lsp/src/core/token_map.rs
index c827220f8bf..ce410e8723c 100644
--- a/sway-lsp/src/core/token_map.rs
+++ b/sway-lsp/src/core/token_map.rs
@@ -8,7 +8,7 @@ use dashmap::{
     DashMap,
 };
 use lsp_types::{Position, Url};
-use std::{thread, time::Duration};
+use std::{path::PathBuf, thread, time::Duration};
 use sway_core::{engine_threading::SpannedWithEngines, language::ty, type_system::TypeId, Engines};
 use sway_types::Ident;
 
@@ -235,6 +235,15 @@ impl<'a> TokenMap {
                 _ => None,
             })
     }
+
+    /// Remove all tokens for the given file from the token map.
+    pub fn remove_tokens_for_file(&self, path_to_remove: &PathBuf) {
+        self.0.retain(|key, _value| {
+            key.path
+                .as_ref()
+                .map_or(true, |path| path != path_to_remove)
+        });
+    }
 }
 
 impl std::ops::Deref for TokenMap {
diff --git a/sway-lsp/src/error.rs b/sway-lsp/src/error.rs
index 740a1127d46..40cbe9e6aab 100644
--- a/sway-lsp/src/error.rs
+++ b/sway-lsp/src/error.rs
@@ -1,3 +1,4 @@
+use lsp_types::Range;
 use swayfmt::FormatterError;
 use thiserror::Error;
 
@@ -14,6 +15,8 @@ pub enum LanguageServerError {
     // Top level errors
     #[error("Failed to create build plan. {0}")]
     BuildPlanFailed(anyhow::Error),
+    #[error("Build Plan Cache is empty")]
+    BuildPlanCacheIsEmpty,
     #[error("Failed to compile. {0}")]
     FailedToCompile(anyhow::Error),
     #[error("Failed to parse document")]
@@ -44,6 +47,13 @@ pub enum DocumentError {
     UnableToWriteFile { path: String, err: String },
     #[error("File wasn't able to be removed at path {:?} : {:?}", path, err)]
     UnableToRemoveFile { path: String, err: String },
+
+    #[error("Permission denied for path {:?}", path)]
+    PermissionDenied { path: String },
+    #[error("IO error for path {:?} : {:?}", path, error)]
+    IOError { path: String, error: String },
+    #[error("Invalid range {:?}", range)]
+    InvalidRange { range: Range },
 }
 
 #[derive(Debug, Error, PartialEq, Eq)]
diff --git a/sway-lsp/src/handlers/notification.rs b/sway-lsp/src/handlers/notification.rs
index 99cb0406bef..7c7dfddf7cc 100644
--- a/sway-lsp/src/handlers/notification.rs
+++ b/sway-lsp/src/handlers/notification.rs
@@ -2,10 +2,7 @@
 //! Protocol. This module specifically handles notification messages sent by the Client.
 
 use crate::{
-    core::{
-        document::{self, Documents},
-        session::Session,
-    },
+    core::{document::Documents, session::Session},
     error::LanguageServerError,
     server_state::{CompilationContext, ServerState, TaskMessage},
 };
@@ -89,7 +86,10 @@ pub async fn handle_did_change_text_document(
     state: &ServerState,
     params: DidChangeTextDocumentParams,
 ) -> Result<(), LanguageServerError> {
-    if let Err(err) = document::mark_file_as_dirty(&params.text_document.uri) {
+    if let Err(err) = state
+        .pid_locked_files
+        .mark_file_as_dirty(&params.text_document.uri)
+    {
         tracing::warn!("Failed to mark file as dirty: {}", err);
     }
 
@@ -111,7 +111,8 @@ pub async fn handle_did_change_text_document(
         session.clone(),
         &uri,
         Some(params.text_document.version),
-        true,
+        // TODO: Set this back to true once https://github.com/FuelLabs/sway/issues/6576 is fixed.
+        false,
         file_versions,
     );
     Ok(())
@@ -138,7 +139,9 @@ pub(crate) async fn handle_did_save_text_document(
     state: &ServerState,
     params: DidSaveTextDocumentParams,
 ) -> Result<(), LanguageServerError> {
-    document::remove_dirty_flag(&params.text_document.uri)?;
+    state
+        .pid_locked_files
+        .remove_dirty_flag(&params.text_document.uri)?;
     let (uri, session) = state
         .uri_and_session_from_workspace(&params.text_document.uri)
         .await?;
@@ -159,7 +162,7 @@ pub(crate) async fn handle_did_change_watched_files(
     for event in params.changes {
         let (uri, _) = state.uri_and_session_from_workspace(&event.uri).await?;
         if let FileChangeType::DELETED = event.typ {
-            document::remove_dirty_flag(&event.uri)?;
+            state.pid_locked_files.remove_dirty_flag(&event.uri)?;
             let _ = state.documents.remove_document(&uri);
         }
     }
diff --git a/sway-lsp/src/handlers/request.rs b/sway-lsp/src/handlers/request.rs
index d6d53a54a26..fb4b72d86a8 100644
--- a/sway-lsp/src/handlers/request.rs
+++ b/sway-lsp/src/handlers/request.rs
@@ -4,7 +4,7 @@
 use crate::{
     capabilities, core::session::build_plan, lsp_ext, server_state::ServerState, utils::debug,
 };
-use forc_tracing::{init_tracing_subscriber, TracingSubscriberOptions, TracingWriterMode};
+use forc_tracing::{tracing_subscriber, FmtSpan, StdioTracingWriter, TracingWriterMode};
 use lsp_types::{
     CodeLens, CompletionResponse, DocumentFormattingParams, DocumentSymbolResponse,
     InitializeResult, InlayHint, InlayHintParams, PrepareRenameResponse, RenameParams,
@@ -40,12 +40,14 @@ pub fn handle_initialize(
     // Initializing tracing library based on the user's config
     let config = state.config.read();
     if config.logging.level != LevelFilter::OFF {
-        let tracing_options = TracingSubscriberOptions {
-            log_level: Some(config.logging.level),
-            writer_mode: Some(TracingWriterMode::Stderr),
-            ..Default::default()
-        };
-        init_tracing_subscriber(tracing_options);
+        tracing_subscriber::fmt::Subscriber::builder()
+            .with_ansi(false)
+            .with_max_level(config.logging.level)
+            .with_span_events(FmtSpan::CLOSE)
+            .with_writer(StdioTracingWriter {
+                writer_mode: TracingWriterMode::Stderr,
+            })
+            .init();
     }
     tracing::info!("Initializing the Sway Language Server");
     Ok(InitializeResult {
@@ -132,6 +134,7 @@ pub async fn handle_hover(
                 &state.keyword_docs,
                 &uri,
                 position,
+                state.config.read().client.clone(),
             ))
         }
         Err(err) => {
@@ -213,6 +216,26 @@ pub async fn handle_document_highlight(
     }
 }
 
+pub async fn handle_references(
+    state: &ServerState,
+    params: lsp_types::ReferenceParams,
+) -> Result<Option<Vec<lsp_types::Location>>> {
+    let _ = state.wait_for_parsing().await;
+    match state
+        .uri_and_session_from_workspace(&params.text_document_position.text_document.uri)
+        .await
+    {
+        Ok((uri, session)) => {
+            let position = params.text_document_position.position;
+            Ok(session.token_references(&uri, position))
+        }
+        Err(err) => {
+            tracing::error!("{}", err.to_string());
+            Ok(None)
+        }
+    }
+}
+
 pub async fn handle_formatting(
     state: &ServerState,
     params: DocumentFormattingParams,
@@ -310,7 +333,7 @@ pub async fn handle_semantic_tokens_full(
     }
 }
 
-pub(crate) async fn handle_inlay_hints(
+pub async fn handle_inlay_hints(
     state: &ServerState,
     params: InlayHintParams,
 ) -> Result<Option<Vec<InlayHint>>> {
diff --git a/sway-lsp/src/lib.rs b/sway-lsp/src/lib.rs
index f2d60ec5e23..696d18208a9 100644
--- a/sway-lsp/src/lib.rs
+++ b/sway-lsp/src/lib.rs
@@ -62,6 +62,7 @@ pub fn server_capabilities() -> ServerCapabilities {
                 work_done_progress: Some(true),
             },
         })),
+        references_provider: Some(OneOf::Left(true)),
         semantic_tokens_provider: Some(
             SemanticTokensOptions {
                 legend: SemanticTokensLegend {
diff --git a/sway-lsp/src/server.rs b/sway-lsp/src/server.rs
index 9f044e64b89..1a5f4e7c11f 100644
--- a/sway-lsp/src/server.rs
+++ b/sway-lsp/src/server.rs
@@ -2,7 +2,6 @@
 //! It provides an interface between the LSP protocol and the sway-lsp internals.
 
 use crate::{
-    core::document,
     handlers::{notification, request},
     lsp_ext::{MetricsParams, OnEnterParams, ShowAstParams, VisualizeParams},
     server_state::ServerState,
@@ -13,10 +12,10 @@ use lsp_types::{
     DidCloseTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams,
     DocumentFormattingParams, DocumentHighlight, DocumentHighlightParams, DocumentSymbolParams,
     DocumentSymbolResponse, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverParams,
-    InitializeParams, InitializeResult, InitializedParams, InlayHint, InlayHintParams,
-    PrepareRenameResponse, RenameParams, SemanticTokensParams, SemanticTokensRangeParams,
-    SemanticTokensRangeResult, SemanticTokensResult, TextDocumentIdentifier,
-    TextDocumentPositionParams, TextEdit, WorkspaceEdit,
+    InitializeParams, InitializeResult, InitializedParams, InlayHint, InlayHintParams, Location,
+    PrepareRenameResponse, ReferenceParams, RenameParams, SemanticTokensParams,
+    SemanticTokensRangeParams, SemanticTokensRangeResult, SemanticTokensResult,
+    TextDocumentIdentifier, TextDocumentPositionParams, TextEdit, WorkspaceEdit,
 };
 use sway_utils::PerformanceData;
 use tower_lsp::{jsonrpc::Result, LanguageServer};
@@ -28,6 +27,7 @@ impl LanguageServer for ServerState {
     }
 
     async fn initialized(&self, _: InitializedParams) {
+        let _p = tracing::trace_span!("parse_text").entered();
         tracing::info!("Sway Language Server Initialized");
     }
 
@@ -42,7 +42,10 @@ impl LanguageServer for ServerState {
     }
 
     async fn did_close(&self, params: DidCloseTextDocumentParams) {
-        if let Err(err) = document::remove_dirty_flag(&params.text_document.uri) {
+        if let Err(err) = self
+            .pid_locked_files
+            .remove_dirty_flag(&params.text_document.uri)
+        {
             tracing::error!("{}", err.to_string());
         }
     }
@@ -134,6 +137,10 @@ impl LanguageServer for ServerState {
     async fn inlay_hint(&self, params: InlayHintParams) -> Result<Option<Vec<InlayHint>>> {
         request::handle_inlay_hints(self, params).await
     }
+
+    async fn references(&self, params: ReferenceParams) -> Result<Option<Vec<Location>>> {
+        request::handle_references(self, params).await
+    }
 }
 
 // Custom LSP-Server Methods
diff --git a/sway-lsp/src/server_state.rs b/sway-lsp/src/server_state.rs
index 4415f0b2d91..2c39abddeac 100644
--- a/sway-lsp/src/server_state.rs
+++ b/sway-lsp/src/server_state.rs
@@ -3,19 +3,22 @@
 use crate::{
     config::{Config, GarbageCollectionConfig, Warnings},
     core::{
-        document::Documents,
+        document::{Documents, PidLockedFiles},
         session::{self, Session},
     },
     error::{DirectoryError, DocumentError, LanguageServerError},
     utils::{debug, keyword_docs::KeywordDocs},
 };
 use crossbeam_channel::{Receiver, Sender};
-use dashmap::DashMap;
+use dashmap::{mapref::multiple::RefMulti, DashMap};
 use forc_pkg::manifest::GenericManifestFile;
 use forc_pkg::PackageManifestFile;
 use lsp_types::{Diagnostic, Url};
-use parking_lot::RwLock;
-use std::{collections::BTreeMap, process::Command};
+use parking_lot::{Mutex, RwLock};
+use std::{
+    collections::{BTreeMap, VecDeque},
+    process::Command,
+};
 use std::{
     mem,
     path::PathBuf,
@@ -28,13 +31,17 @@ use sway_core::LspConfig;
 use tokio::sync::Notify;
 use tower_lsp::{jsonrpc, Client};
 
+const DEFAULT_SESSION_CACHE_CAPACITY: usize = 4;
+
 /// `ServerState` is the primary mutable state of the language server
 pub struct ServerState {
     pub(crate) client: Option<Client>,
     pub config: Arc<RwLock<Config>>,
     pub(crate) keyword_docs: Arc<KeywordDocs>,
-    /// A collection of [Session]s, each of which represents a project that has been opened in the users workspace
-    pub(crate) sessions: Arc<DashMap<PathBuf, Arc<Session>>>,
+    /// A Least Recently Used (LRU) cache of [Session]s, each representing a project opened in the user's workspace.
+    /// This cache limits memory usage by maintaining a fixed number of active sessions, automatically
+    /// evicting the least recently used sessions when the capacity is reached.
+    pub sessions: LruSessionCache,
     pub documents: Documents,
     // Compilation thread related fields
     pub(crate) retrigger_compilation: Arc<AtomicBool>,
@@ -42,6 +49,8 @@ pub struct ServerState {
     pub(crate) cb_tx: Sender<TaskMessage>,
     pub(crate) cb_rx: Arc<Receiver<TaskMessage>>,
     pub(crate) finished_compilation: Arc<Notify>,
+    pub(crate) pid_locked_files: PidLockedFiles,
+    manifest_cache: DashMap<Url, Arc<PathBuf>>,
     last_compilation_state: Arc<RwLock<LastCompilationState>>,
 }
 
@@ -52,13 +61,15 @@ impl Default for ServerState {
             client: None,
             config: Arc::new(RwLock::new(Config::default())),
             keyword_docs: Arc::new(KeywordDocs::new()),
-            sessions: Arc::new(DashMap::new()),
+            sessions: LruSessionCache::new(DEFAULT_SESSION_CACHE_CAPACITY),
             documents: Documents::new(),
             retrigger_compilation: Arc::new(AtomicBool::new(false)),
             is_compiling: Arc::new(AtomicBool::new(false)),
             cb_tx,
             cb_rx: Arc::new(cb_rx),
             finished_compilation: Arc::new(Notify::new()),
+            pid_locked_files: PidLockedFiles::new(),
+            manifest_cache: DashMap::new(),
             last_compilation_state: Arc::new(RwLock::new(LastCompilationState::Uninitialized)),
         };
         // Spawn a new thread dedicated to handling compilation tasks
@@ -126,19 +137,17 @@ impl ServerState {
                         let session = ctx.session.as_ref().unwrap().clone();
                         let mut engines_clone = session.engines.read().clone();
 
-                        if let Some(version) = ctx.version {
-                            // Perform garbage collection at configured intervals if enabled to manage memory usage.
-                            if ctx.gc_options.gc_enabled
-                                && version % ctx.gc_options.gc_frequency == 0
+                        // Perform garbage collection if enabled to manage memory usage.
+                        if ctx.gc_options.gc_enabled {
+                            // Call this on the engines clone so we don't clear types that are still in use
+                            // and might be needed in the case cancel compilation was triggered.
+                            if let Err(err) =
+                                session.garbage_collect_module(&mut engines_clone, &uri)
                             {
-                                // Call this on the engines clone so we don't clear types that are still in use
-                                // and might be needed in the case cancel compilation was triggered.
-                                if let Err(err) = session.garbage_collect(&mut engines_clone) {
-                                    tracing::error!(
-                                        "Unable to perform garbage collection: {}",
-                                        err.to_string()
-                                    );
-                                }
+                                tracing::error!(
+                                    "Unable to perform garbage collection: {}",
+                                    err.to_string()
+                                );
                             }
                         }
 
@@ -146,7 +155,6 @@ impl ServerState {
                             optimized_build: ctx.optimized_build,
                             file_versions: ctx.file_versions,
                         });
-
                         // Set the is_compiling flag to true so that the wait_for_parsing function knows that we are compiling
                         is_compiling.store(true, Ordering::SeqCst);
                         match session::parse_project(
@@ -168,6 +176,10 @@ impl ServerState {
                                             // Because the engines_clone has garbage collection applied. If the workspace AST was reused, we need to keep the old engines
                                             // as the engines_clone might have cleared some types that are still in use.
                                             if metrics.reused_programs == 0 {
+                                                // Commit local changes in the programs, module, and function caches to the shared state.
+                                                // This ensures that any modifications made during compilation are preserved
+                                                // before we swap the engines.
+                                                engines_clone.qe().commit();
                                                 // The compiler did not reuse the workspace AST.
                                                 // We need to overwrite the old engines with the engines clone.
                                                 mem::swap(
@@ -257,6 +269,7 @@ impl ServerState {
     }
 
     pub fn shutdown_server(&self) -> jsonrpc::Result<()> {
+        let _p = tracing::trace_span!("shutdown_server").entered();
         tracing::info!("Shutting Down the Sway Language Server");
 
         // Drain pending compilation requests
@@ -324,16 +337,9 @@ impl ServerState {
         diagnostics_to_publish
     }
 
-    async fn init_session(&self, uri: &Url) -> Result<(), LanguageServerError> {
-        let session = Arc::new(Session::new());
-        let project_name = session.init(uri, &self.documents).await?;
-        self.sessions.insert(project_name, session);
-        Ok(())
-    }
-
     /// Constructs and returns a tuple of `(Url, Arc<Session>)` from a given workspace URI.
     /// The returned URL represents the temp directory workspace.
-    pub(crate) async fn uri_and_session_from_workspace(
+    pub async fn uri_and_session_from_workspace(
         &self,
         workspace_uri: &Url,
     ) -> Result<(Url, Arc<Session>), LanguageServerError> {
@@ -343,31 +349,196 @@ impl ServerState {
     }
 
     async fn url_to_session(&self, uri: &Url) -> Result<Arc<Session>, LanguageServerError> {
-        let path = PathBuf::from(uri.path());
-        let manifest = PackageManifestFile::from_dir(&path).map_err(|_| {
-            DocumentError::ManifestFileNotFound {
-                dir: path.to_string_lossy().to_string(),
-            }
-        })?;
-
-        // strip Forc.toml from the path to get the manifest directory
-        let manifest_dir = manifest
-            .path()
-            .parent()
-            .ok_or(DirectoryError::ManifestDirNotFound)?
-            .to_path_buf();
-
-        let session = if let Some(item) = self.sessions.try_get(&manifest_dir).try_unwrap() {
-            item.value().clone()
+        // Try to get the manifest directory from the cache
+        let manifest_dir = if let Some(cached_dir) = self.manifest_cache.get(uri) {
+            cached_dir.clone()
         } else {
-            // If no session can be found, then we need to call init and insert a new session into the map
-            self.init_session(uri).await?;
-            self.sessions
-                .try_get(&manifest_dir)
-                .try_unwrap()
-                .map(|item| item.value().clone())
-                .expect("no session found even though it was just inserted into the map")
+            // Otherwise, find the manifest directory from the uri and cache it
+            let path = PathBuf::from(uri.path());
+            let manifest = PackageManifestFile::from_dir(&path).map_err(|_| {
+                DocumentError::ManifestFileNotFound {
+                    dir: path.to_string_lossy().to_string(),
+                }
+            })?;
+            let dir = Arc::new(
+                manifest
+                    .path()
+                    .parent()
+                    .ok_or(DirectoryError::ManifestDirNotFound)?
+                    .to_path_buf(),
+            );
+            self.manifest_cache.insert(uri.clone(), dir.clone());
+            dir
         };
+
+        // If the session is already in the cache, return it
+        if let Some(session) = self.sessions.get(&manifest_dir) {
+            return Ok(session);
+        }
+
+        // If no session can be found, then we need to call init and insert a new session into the map
+        let session = Arc::new(Session::new());
+        session.init(uri, &self.documents).await?;
+        self.sessions
+            .insert((*manifest_dir).clone(), session.clone());
+
         Ok(session)
     }
 }
+
+/// A Least Recently Used (LRU) cache for storing and managing `Session` objects.
+/// This cache helps limit memory usage by maintaining a fixed number of active sessions.
+pub struct LruSessionCache {
+    /// Stores the actual `Session` objects, keyed by their file paths.
+    sessions: Arc<DashMap<PathBuf, Arc<Session>>>,
+    /// Keeps track of the order in which sessions were accessed, with most recent at the front.
+    usage_order: Arc<Mutex<VecDeque<PathBuf>>>,
+    /// The maximum number of sessions that can be stored in the cache.
+    capacity: usize,
+}
+
+impl LruSessionCache {
+    /// Creates a new `LruSessionCache` with the specified capacity.
+    pub fn new(capacity: usize) -> Self {
+        LruSessionCache {
+            sessions: Arc::new(DashMap::new()),
+            usage_order: Arc::new(Mutex::new(VecDeque::with_capacity(capacity))),
+            capacity,
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = RefMulti<'_, PathBuf, Arc<Session>>> {
+        self.sessions.iter()
+    }
+
+    /// Retrieves a session from the cache and updates its position to the front of the usage order.
+    pub fn get(&self, path: &PathBuf) -> Option<Arc<Session>> {
+        if let Some(session) = self.sessions.try_get(path).try_unwrap() {
+            if self.sessions.len() >= self.capacity {
+                self.move_to_front(path);
+            }
+            Some(session.clone())
+        } else {
+            None
+        }
+    }
+
+    /// Inserts or updates a session in the cache.
+    /// If at capacity and inserting a new session, evicts the least recently used one.
+    /// For existing sessions, updates their position in the usage order if at capacity.
+    pub fn insert(&self, path: PathBuf, session: Arc<Session>) {
+        if let Some(mut entry) = self.sessions.get_mut(&path) {
+            // Session already exists, update it
+            *entry = session;
+            self.move_to_front(&path);
+        } else {
+            // New session
+            if self.sessions.len() >= self.capacity {
+                self.evict_least_used();
+            }
+            self.sessions.insert(path.clone(), session);
+            let mut order = self.usage_order.lock();
+            order.push_front(path);
+        }
+    }
+
+    /// Moves the specified path to the front of the usage order, marking it as most recently used.
+    fn move_to_front(&self, path: &PathBuf) {
+        tracing::trace!("Moving path to front of usage order: {:?}", path);
+        let mut order = self.usage_order.lock();
+        if let Some(index) = order.iter().position(|p| p == path) {
+            order.remove(index);
+        }
+        order.push_front(path.clone());
+    }
+
+    /// Removes the least recently used session from the cache when the capacity is reached.
+    fn evict_least_used(&self) {
+        let mut order = self.usage_order.lock();
+        if let Some(old_path) = order.pop_back() {
+            tracing::trace!(
+                "Cache at capacity. Evicting least used session: {:?}",
+                old_path
+            );
+            self.sessions.remove(&old_path);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_lru_session_cache_insertion_and_retrieval() {
+        let cache = LruSessionCache::new(2);
+        let path1 = PathBuf::from("/path/1");
+        let path2 = PathBuf::from("/path/2");
+        let session1 = Arc::new(Session::new());
+        let session2 = Arc::new(Session::new());
+
+        cache.insert(path1.clone(), session1.clone());
+        cache.insert(path2.clone(), session2.clone());
+
+        assert!(Arc::ptr_eq(&cache.get(&path1).unwrap(), &session1));
+        assert!(Arc::ptr_eq(&cache.get(&path2).unwrap(), &session2));
+    }
+
+    #[test]
+    fn test_lru_session_cache_capacity() {
+        let cache = LruSessionCache::new(2);
+        let path1 = PathBuf::from("/path/1");
+        let path2 = PathBuf::from("/path/2");
+        let path3 = PathBuf::from("/path/3");
+        let session1 = Arc::new(Session::new());
+        let session2 = Arc::new(Session::new());
+        let session3 = Arc::new(Session::new());
+
+        cache.insert(path1.clone(), session1);
+        cache.insert(path2.clone(), session2);
+        cache.insert(path3.clone(), session3);
+
+        assert!(cache.get(&path1).is_none());
+        assert!(cache.get(&path2).is_some());
+        assert!(cache.get(&path3).is_some());
+    }
+
+    #[test]
+    fn test_lru_session_cache_update_order() {
+        let cache = LruSessionCache::new(2);
+        let path1 = PathBuf::from("/path/1");
+        let path2 = PathBuf::from("/path/2");
+        let path3 = PathBuf::from("/path/3");
+        let session1 = Arc::new(Session::new());
+        let session2 = Arc::new(Session::new());
+        let session3 = Arc::new(Session::new());
+
+        cache.insert(path1.clone(), session1.clone());
+        cache.insert(path2.clone(), session2.clone());
+
+        // Access path1 to move it to the front
+        cache.get(&path1);
+
+        // Insert path3, which should evict path2
+        cache.insert(path3.clone(), session3);
+
+        assert!(cache.get(&path1).is_some());
+        assert!(cache.get(&path2).is_none());
+        assert!(cache.get(&path3).is_some());
+    }
+
+    #[test]
+    fn test_lru_session_cache_overwrite() {
+        let cache = LruSessionCache::new(2);
+        let path1 = PathBuf::from("/path/1");
+        let session1 = Arc::new(Session::new());
+        let session1_new = Arc::new(Session::new());
+
+        cache.insert(path1.clone(), session1);
+        cache.insert(path1.clone(), session1_new.clone());
+
+        assert!(Arc::ptr_eq(&cache.get(&path1).unwrap(), &session1_new));
+    }
+}
diff --git a/sway-lsp/src/traverse/lexed_tree.rs b/sway-lsp/src/traverse/lexed_tree.rs
index f441321c500..a95f0b55881 100644
--- a/sway-lsp/src/traverse/lexed_tree.rs
+++ b/sway-lsp/src/traverse/lexed_tree.rs
@@ -4,8 +4,8 @@ use crate::{
 };
 use rayon::iter::{ParallelBridge, ParallelIterator};
 use sway_ast::{
-    assignable::ElementAccess, expr::LoopControlFlow, ty::TyTupleDescriptor, Assignable,
-    CodeBlockContents, ConfigurableField, Expr, ExprArrayDescriptor, ExprStructField,
+    assignable::ElementAccess, attribute::Annotated, expr::LoopControlFlow, ty::TyTupleDescriptor,
+    Assignable, CodeBlockContents, ConfigurableField, Expr, ExprArrayDescriptor, ExprStructField,
     ExprTupleDescriptor, FnArg, FnArgs, FnSignature, IfCondition, IfExpr, ItemAbi,
     ItemConfigurable, ItemConst, ItemEnum, ItemFn, ItemImpl, ItemImplItem, ItemKind, ItemStorage,
     ItemStruct, ItemTrait, ItemTypeAlias, ItemUse, MatchBranchKind, ModuleKind, Pattern,
@@ -15,21 +15,28 @@ use sway_ast::{
 use sway_core::language::{lexed::LexedProgram, HasSubmodules};
 use sway_types::{Ident, Span, Spanned};
 
-pub fn parse(lexed_program: &LexedProgram, ctx: &ParseContext) {
-    insert_module_kind(ctx, &lexed_program.root.tree.kind);
-    adaptive_iter(&lexed_program.root.tree.items, |item| {
-        item.value.parse(ctx);
-    });
-
-    lexed_program
-        .root
-        .submodules_recursive()
-        .for_each(|(_, dep)| {
-            insert_module_kind(ctx, &dep.module.tree.kind);
-            adaptive_iter(&dep.module.tree.items, |item| {
-                item.value.parse(ctx);
+pub struct LexedTree<'a> {
+    ctx: &'a ParseContext<'a>,
+}
+
+impl<'a> LexedTree<'a> {
+    pub fn new(ctx: &'a ParseContext<'a>) -> Self {
+        Self { ctx }
+    }
+
+    pub fn traverse_node(&self, node: &Annotated<ItemKind>) {
+        node.value.parse(self.ctx);
+    }
+
+    pub fn collect_module_kinds(&self, lexed_program: &LexedProgram) {
+        insert_module_kind(self.ctx, &lexed_program.root.tree.kind);
+        lexed_program
+            .root
+            .submodules_recursive()
+            .for_each(|(_, dep)| {
+                insert_module_kind(self.ctx, &dep.module.tree.kind);
             });
-        });
+    }
 }
 
 fn insert_module_kind(ctx: &ParseContext, kind: &ModuleKind) {
diff --git a/sway-lsp/src/traverse/parsed_tree.rs b/sway-lsp/src/traverse/parsed_tree.rs
index 08b8f647876..880915f915b 100644
--- a/sway-lsp/src/traverse/parsed_tree.rs
+++ b/sway-lsp/src/traverse/parsed_tree.rs
@@ -23,15 +23,15 @@ use sway_core::{
             ConstantDeclaration, Declaration, DelineatedPathExpression, EnumDeclaration,
             EnumVariant, Expression, ExpressionKind, ForLoopExpression,
             FunctionApplicationExpression, FunctionDeclaration, FunctionParameter, IfExpression,
-            ImplItem, ImplSelf, ImplTrait, ImportType, IncludeStatement,
-            IntrinsicFunctionExpression, LazyOperatorExpression, MatchExpression,
-            MethodApplicationExpression, MethodName, ParseModule, ParseProgram, ParseSubmodule,
-            QualifiedPathType, ReassignmentExpression, ReassignmentTarget, RefExpression,
-            Scrutinee, StorageAccessExpression, StorageDeclaration, StorageEntry, StorageField,
-            StorageNamespace, StructDeclaration, StructExpression, StructExpressionField,
-            StructField, StructScrutineeField, SubfieldExpression, Supertrait, TraitDeclaration,
-            TraitFn, TraitItem, TraitTypeDeclaration, TupleIndexExpression, TypeAliasDeclaration,
-            UseStatement, VariableDeclaration, WhileLoopExpression,
+            ImplItem, ImplSelfOrTrait, ImportType, IncludeStatement, IntrinsicFunctionExpression,
+            LazyOperatorExpression, MatchExpression, MethodApplicationExpression, MethodName,
+            ParseModule, ParseProgram, ParseSubmodule, QualifiedPathType, ReassignmentExpression,
+            ReassignmentTarget, RefExpression, Scrutinee, StorageAccessExpression,
+            StorageDeclaration, StorageEntry, StorageField, StorageNamespace, StructDeclaration,
+            StructExpression, StructExpressionField, StructField, StructScrutineeField,
+            SubfieldExpression, Supertrait, TraitDeclaration, TraitFn, TraitItem,
+            TraitTypeDeclaration, TupleIndexExpression, TypeAliasDeclaration, UseStatement,
+            VariableDeclaration, WhileLoopExpression,
         },
         CallPathTree, HasSubmodules, Literal,
     },
@@ -126,14 +126,14 @@ impl Parse for Declaration {
             Declaration::StructDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::EnumDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::EnumVariantDeclaration(_decl) => unreachable!(),
-            Declaration::ImplTrait(decl_id) => decl_id.parse(ctx),
-            Declaration::ImplSelf(decl_id) => decl_id.parse(ctx),
+            Declaration::ImplSelfOrTrait(decl_id) => decl_id.parse(ctx),
             Declaration::AbiDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::ConstantDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::ConfigurableDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::StorageDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::TypeAliasDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::TraitTypeDeclaration(decl_id) => decl_id.parse(ctx),
+            Declaration::TraitFnDeclaration(decl_id) => decl_id.parse(ctx),
         }
     }
 }
@@ -779,58 +779,49 @@ impl Parse for ParsedDeclId<EnumDeclaration> {
     }
 }
 
-impl Parse for ParsedDeclId<ImplTrait> {
+impl Parse for ParsedDeclId<ImplSelfOrTrait> {
     fn parse(&self, ctx: &ParseContext) {
-        let impl_trait = ctx.engines.pe().get_impl_trait(self);
-        adaptive_iter(&impl_trait.trait_name.prefixes, |ident| {
+        let impl_self_or_trait = ctx.engines.pe().get_impl_self_or_trait(self);
+        adaptive_iter(&impl_self_or_trait.trait_name.prefixes, |ident| {
             ctx.tokens.insert(
                 ctx.ident(ident),
                 Token::from_parsed(AstToken::Ident(ident.clone()), SymbolKind::Module),
             );
         });
         ctx.tokens.insert(
-            ctx.ident(&impl_trait.trait_name.suffix),
+            ctx.ident(&impl_self_or_trait.trait_name.suffix),
             Token::from_parsed(
-                AstToken::Declaration(Declaration::ImplTrait(*self)),
+                AstToken::Declaration(Declaration::ImplSelfOrTrait(*self)),
                 SymbolKind::Trait,
             ),
         );
-        impl_trait.implementing_for.parse(ctx);
-        adaptive_iter(&impl_trait.impl_type_parameters, |type_param| {
-            type_param.parse(ctx);
-        });
-        adaptive_iter(&impl_trait.items, |item| match item {
-            ImplItem::Fn(fn_decl) => fn_decl.parse(ctx),
-            ImplItem::Constant(const_decl) => const_decl.parse(ctx),
-            ImplItem::Type(type_decl) => type_decl.parse(ctx),
-        });
-    }
-}
-
-impl Parse for ParsedDeclId<ImplSelf> {
-    fn parse(&self, ctx: &ParseContext) {
-        let impl_self = ctx.engines.pe().get_impl_self(self);
         if let TypeInfo::Custom {
             qualified_call_path,
             type_arguments,
             root_type_id: _,
-        } = &&*ctx.engines.te().get(impl_self.implementing_for.type_id)
+        } = &&*ctx
+            .engines
+            .te()
+            .get(impl_self_or_trait.implementing_for.type_id)
         {
             ctx.tokens.insert(
                 ctx.ident(&qualified_call_path.call_path.suffix),
                 Token::from_parsed(
-                    AstToken::Declaration(Declaration::ImplSelf(*self)),
+                    AstToken::Declaration(Declaration::ImplSelfOrTrait(*self)),
                     SymbolKind::Struct,
                 ),
             );
             if let Some(type_arguments) = type_arguments {
                 adaptive_iter(type_arguments, |type_arg| type_arg.parse(ctx));
             }
+        } else {
+            impl_self_or_trait.implementing_for.parse(ctx);
         }
-        adaptive_iter(&impl_self.impl_type_parameters, |type_param| {
+
+        adaptive_iter(&impl_self_or_trait.impl_type_parameters, |type_param| {
             type_param.parse(ctx);
         });
-        adaptive_iter(&impl_self.items, |item| match item {
+        adaptive_iter(&impl_self_or_trait.items, |item| match item {
             ImplItem::Fn(fn_decl) => fn_decl.parse(ctx),
             ImplItem::Constant(const_decl) => const_decl.parse(ctx),
             ImplItem::Type(type_decl) => type_decl.parse(ctx),
@@ -1051,6 +1042,9 @@ impl Parse for TypeArgument {
                 );
                 type_arg.parse(ctx);
             }
+            TypeInfo::Slice(type_arg) => {
+                type_arg.parse(ctx);
+            }
             TypeInfo::Tuple(type_arguments) => {
                 adaptive_iter(type_arguments, |type_arg| type_arg.parse(ctx));
             }
diff --git a/sway-lsp/src/traverse/typed_tree.rs b/sway-lsp/src/traverse/typed_tree.rs
index dfd350393e8..3c6098cc43d 100644
--- a/sway-lsp/src/traverse/typed_tree.rs
+++ b/sway-lsp/src/traverse/typed_tree.rs
@@ -82,7 +82,7 @@ impl Parse for ty::TyDecl {
             ty::TyDecl::StructDecl(decl) => decl.parse(ctx),
             ty::TyDecl::EnumDecl(decl) => collect_enum(ctx, &decl.decl_id, self),
             ty::TyDecl::EnumVariantDecl(decl) => collect_enum(ctx, decl.enum_ref.id(), self),
-            ty::TyDecl::ImplTrait(decl) => decl.parse(ctx),
+            ty::TyDecl::ImplSelfOrTrait(decl) => decl.parse(ctx),
             ty::TyDecl::AbiDecl(decl) => decl.parse(ctx),
             ty::TyDecl::GenericTypeForFunctionScope(decl) => decl.parse(ctx),
             ty::TyDecl::ErrorRecovery(_, _) => {}
@@ -113,7 +113,7 @@ impl Parse for ty::TySideEffect {
                         if let Some(span) = ctx
                             .namespace
                             .submodule(ctx.engines, mod_path)
-                            .and_then(|tgt_submod| tgt_submod.span.clone())
+                            .and_then(|tgt_submod| tgt_submod.span().clone())
                         {
                             token.type_def = Some(TypeDefinition::Ident(Ident::new(span)));
                         }
@@ -169,7 +169,7 @@ impl Parse for ty::TySideEffect {
                             if let Some(span) = ctx
                                 .namespace
                                 .submodule(ctx.engines, call_path)
-                                .and_then(|tgt_submod| tgt_submod.span.clone())
+                                .and_then(|tgt_submod| tgt_submod.span().clone())
                             {
                                 token.type_def = Some(TypeDefinition::Ident(Ident::new(span)));
                             }
@@ -192,7 +192,7 @@ impl Parse for ty::TySideEffect {
                     if let Some(span) = ctx
                         .namespace
                         .submodule(ctx.engines, &[mod_name.clone()])
-                        .and_then(|tgt_submod| tgt_submod.span.clone())
+                        .and_then(|tgt_submod| tgt_submod.span().clone())
                     {
                         token.type_def = Some(TypeDefinition::Ident(Ident::new(span)));
                     }
@@ -719,10 +719,10 @@ impl Parse for ty::StructDecl {
     }
 }
 
-impl Parse for ty::ImplTrait {
+impl Parse for ty::ImplSelfOrTrait {
     fn parse(&self, ctx: &ParseContext) {
-        let impl_trait_decl = ctx.engines.de().get_impl_trait(&self.decl_id);
-        let ty::TyImplTrait {
+        let impl_trait_decl = ctx.engines.de().get_impl_self_or_trait(&self.decl_id);
+        let ty::TyImplSelfOrTrait {
             impl_type_parameters,
             trait_name,
             trait_type_arguments,
@@ -754,9 +754,9 @@ impl Parse for ty::ImplTrait {
             .tokens
             .try_get_mut_with_retry(&ctx.ident(&trait_name.suffix))
         {
-            token.typed = Some(TypedAstToken::TypedDeclaration(ty::TyDecl::ImplTrait(
-                self.clone(),
-            )));
+            token.typed = Some(TypedAstToken::TypedDeclaration(
+                ty::TyDecl::ImplSelfOrTrait(self.clone()),
+            ));
             token.type_def = if let Some(decl_ref) = &trait_decl_ref {
                 typed_token = Some(TypedAstToken::TypedArgument(implementing_for.clone()));
                 match &decl_ref.id().clone() {
@@ -981,8 +981,7 @@ impl Parse for ty::TyIntrinsicFunctionKind {
 impl Parse for ty::TyScrutinee {
     fn parse(&self, ctx: &ParseContext) {
         use ty::TyScrutineeVariant::{
-            CatchAll, Configurable, Constant, EnumScrutinee, Literal, Or, StructScrutinee, Tuple,
-            Variable,
+            CatchAll, Constant, EnumScrutinee, Literal, Or, StructScrutinee, Tuple, Variable,
         };
         match &self.variant {
             CatchAll => {}
@@ -992,12 +991,6 @@ impl Parse for ty::TyScrutinee {
                     token.type_def = Some(TypeDefinition::Ident(decl.call_path.suffix.clone()));
                 }
             }
-            Configurable(name, _, decl) => {
-                if let Some(mut token) = ctx.tokens.try_get_mut_with_retry(&ctx.ident(name)) {
-                    token.typed = Some(TypedAstToken::TypedScrutinee(self.clone()));
-                    token.type_def = Some(TypeDefinition::Ident(decl.call_path.suffix.clone()));
-                }
-            }
             Literal(_) => {
                 if let Some(mut token) = ctx
                     .tokens
@@ -1209,7 +1202,7 @@ fn collect_call_path_prefixes(ctx: &ParseContext, prefixes: &[Ident]) {
             if let Some(span) = ctx
                 .namespace
                 .submodule(ctx.engines, mod_path)
-                .and_then(|tgt_submod| tgt_submod.span.clone())
+                .and_then(|tgt_submod| tgt_submod.span().clone())
             {
                 token.kind = SymbolKind::Module;
                 token.type_def = Some(TypeDefinition::Ident(Ident::new(span)));
@@ -1277,6 +1270,9 @@ fn collect_type_id(
         TypeInfo::Array(type_arg, ..) => {
             collect_type_argument(ctx, type_arg);
         }
+        TypeInfo::Slice(type_arg, ..) => {
+            collect_type_argument(ctx, type_arg);
+        }
         TypeInfo::Tuple(type_arguments) => {
             adaptive_iter(type_arguments, |type_arg| {
                 collect_type_argument(ctx, type_arg);
diff --git a/sway-lsp/src/utils/keyword_docs.rs b/sway-lsp/src/utils/keyword_docs.rs
index f26d48a3b37..060118fa234 100644
--- a/sway-lsp/src/utils/keyword_docs.rs
+++ b/sway-lsp/src/utils/keyword_docs.rs
@@ -802,7 +802,7 @@ impl KeywordDocs {
             let name = ident.trim_end_matches("_keyword").to_owned();
             let mut documentation = String::new();
             keyword.attrs.iter().for_each(|attr| {
-                let tokens = attr.tokens.to_token_stream();
+                let tokens = attr.meta.clone().to_token_stream();
                 let lit = extract_lit(tokens);
                 writeln!(documentation, "{lit}").unwrap();
             });
diff --git a/sway-lsp/src/utils/markup.rs b/sway-lsp/src/utils/markup.rs
index 9510674f435..0d2d641e4ea 100644
--- a/sway-lsp/src/utils/markup.rs
+++ b/sway-lsp/src/utils/markup.rs
@@ -4,8 +4,8 @@
 //! markdown for this purpose.
 //! Modified from rust-analyzer.
 use crate::{
-    capabilities::hover::hover_link_contents::RelatedType, core::token::get_range_from_span,
-    utils::document::get_url_from_span,
+    capabilities::hover::hover_link_contents::RelatedType, config::LspClient,
+    core::token::get_range_from_span, utils::document::get_url_from_span,
 };
 use serde_json::{json, Value};
 use std::fmt::{self};
@@ -56,13 +56,18 @@ impl Markup {
     }
 
     /// Adds go-to links if there are any related types, a link to view implementations if there are any,
-    /// or nothing if there are no related types or implementations.
+    /// or nothing if there are no related types or implementations. Only adds links for VSCode clients.
     pub fn maybe_add_links(
         self,
         source_engine: &SourceEngine,
         related_types: &[RelatedType],
         implementations: &[Span],
+        client_config: LspClient,
     ) -> Self {
+        if client_config != LspClient::VsCode {
+            return self;
+        }
+
         if related_types.is_empty() {
             let locations = implementations
                 .iter()
diff --git a/sway-lsp/tests/fixtures/garbage_collection/minimal_script/.gitignore b/sway-lsp/tests/fixtures/garbage_collection/minimal_script/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/sway-lsp/tests/fixtures/garbage_collection/minimal_script/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/Forc.toml b/sway-lsp/tests/fixtures/garbage_collection/minimal_script/Forc.toml
similarity index 81%
rename from test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/Forc.toml
rename to sway-lsp/tests/fixtures/garbage_collection/minimal_script/Forc.toml
index c6b847f7ff8..7813d36bca0 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/Forc.toml
+++ b/sway-lsp/tests/fixtures/garbage_collection/minimal_script/Forc.toml
@@ -1,8 +1,8 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
 license = "Apache-2.0"
+name = "minimal_script"
 implicit-std = false
-name = "unrecognized_opcode"
-entry = "main.sw"
 
 [dependencies]
diff --git a/sway-lsp/tests/fixtures/garbage_collection/minimal_script/src/main.sw b/sway-lsp/tests/fixtures/garbage_collection/minimal_script/src/main.sw
new file mode 100644
index 00000000000..c9f990bb169
--- /dev/null
+++ b/sway-lsp/tests/fixtures/garbage_collection/minimal_script/src/main.sw
@@ -0,0 +1,14 @@
+script;
+
+struct MyStruct {
+    field1: u16,
+}
+
+fn func(s: MyStruct) -> u16 {
+    s.field1
+}
+
+fn main() {
+    let x = MyStruct { field1: 10 };
+    let y = func(x);
+}
\ No newline at end of file
diff --git a/sway-lsp/tests/fixtures/inlay_hints/.gitignore b/sway-lsp/tests/fixtures/inlay_hints/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/sway-lsp/tests/fixtures/inlay_hints/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/sway-lsp/tests/fixtures/inlay_hints/Forc.toml b/sway-lsp/tests/fixtures/inlay_hints/Forc.toml
new file mode 100644
index 00000000000..57a6803b1f1
--- /dev/null
+++ b/sway-lsp/tests/fixtures/inlay_hints/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "inlay_hints"
+implicit-std = false
+
+[dependencies]
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.63.5" }
diff --git a/sway-lsp/tests/fixtures/inlay_hints/src/main.sw b/sway-lsp/tests/fixtures/inlay_hints/src/main.sw
new file mode 100644
index 00000000000..f3071c0f912
--- /dev/null
+++ b/sway-lsp/tests/fixtures/inlay_hints/src/main.sw
@@ -0,0 +1,51 @@
+script;
+
+const CONSTANT: u64 = 42;
+
+enum MyEnum {
+    A: u64,
+}
+struct MyStruct {
+    a: u64,
+}
+fn my_function(foo: u64, bar: u64, long_argument_name: u64) -> u64 {
+    foo + bar + long_argument_name
+}
+fn identity<T>(x: T) -> T {
+    x
+}
+fn two_generics<A, B>(_a: A, b: B) -> B {
+    b
+}
+fn three_generics<A, B, C>(a: A, b: B, _c: C) -> B {
+    let _a: A = a;
+    b
+}
+
+fn main() {
+    let _x = my_function(1, 2, 3);
+    let foo = 1;
+    let _y = my_function(foo, 2, 3);
+    let bar = 2;
+    let _function_call = identity(my_function(1, bar, 3));
+    let _z = my_function(foo, bar, 3);
+    let long_argument_name = 3;
+    let _w = my_function(foo, bar, long_argument_name);
+    let _a: bool = identity(true);
+    let _b: u32 = identity(10u32);
+    let _c: u64 = identity(42);
+    let _e: str = identity("foo");
+    let _f: u64 = two_generics(true, 10);
+    let _g: str = three_generics(true, "foo", 10);
+    let _const = identity(CONSTANT);
+    let _tuple = identity((1, 2, 3));
+    let _array = identity([1, 2, 3]);
+    let _enum = identity(MyEnum::A(1));
+    let s = MyStruct { a: 1 };
+    let _struct_field_access = identity(s.a);
+    let t = (0, 1, 9);
+    let _tuple_elem_access = identity(t.2);
+    let a = [1, 2, 3];
+    let _array_index = identity(a[1]);
+}
+
diff --git a/sway-lsp/tests/fixtures/tokens/abi/Forc.toml b/sway-lsp/tests/fixtures/tokens/abi/Forc.toml
index 4063ea08089..ec8b06e6a46 100644
--- a/sway-lsp/tests/fixtures/tokens/abi/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/abi/Forc.toml
@@ -6,4 +6,4 @@ name = "abi"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/consts/Forc.toml b/sway-lsp/tests/fixtures/tokens/consts/Forc.toml
index ce62f1fc216..b3b77a50ae6 100644
--- a/sway-lsp/tests/fixtures/tokens/consts/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/consts/Forc.toml
@@ -6,4 +6,4 @@ name = "consts"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/fields/Forc.toml b/sway-lsp/tests/fixtures/tokens/fields/Forc.toml
index 961972e7bf2..238f20e47a3 100644
--- a/sway-lsp/tests/fixtures/tokens/fields/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/fields/Forc.toml
@@ -6,4 +6,4 @@ name = "fields"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/matches/Forc.toml b/sway-lsp/tests/fixtures/tokens/matches/Forc.toml
index 9c40268a9be..ab1eb22dc0d 100644
--- a/sway-lsp/tests/fixtures/tokens/matches/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/matches/Forc.toml
@@ -6,4 +6,4 @@ name = "matches"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/paths/Forc.toml b/sway-lsp/tests/fixtures/tokens/paths/Forc.toml
index 808b879d614..57e4e4bd494 100644
--- a/sway-lsp/tests/fixtures/tokens/paths/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/paths/Forc.toml
@@ -6,4 +6,4 @@ name = "paths"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod.sw b/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod.sw
index 874041a52a2..ea7106afe89 100644
--- a/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod.sw
+++ b/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod.sw
@@ -1,3 +1,3 @@
 library;
 
-mod deeper_mod;
+pub mod deeper_mod;
diff --git a/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw b/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw
index 081e10146bf..c44154f7810 100644
--- a/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw
+++ b/sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw
@@ -8,5 +8,5 @@ pub enum DeepEnum {
 }
 
 pub struct DeepStruct<T> {
-    field: T,
+    pub field: T,
 }
diff --git a/sway-lsp/tests/fixtures/tokens/paths/src/main.sw b/sway-lsp/tests/fixtures/tokens/paths/src/main.sw
index d2170afee55..1419f36691c 100644
--- a/sway-lsp/tests/fixtures/tokens/paths/src/main.sw
+++ b/sway-lsp/tests/fixtures/tokens/paths/src/main.sw
@@ -10,9 +10,7 @@ use std::constants::{self, ZERO_B256};
 pub fn fun() {
     let _ = std::option::Option::None;
     let _ = Option::None;
-    let _ = std::vm::evm::evm_address::EvmAddress {
-        value: b256::min(),
-    };
+    let _ = std::vm::evm::evm_address::EvmAddress::zero();
 
     test_mod::test_fun();
     deep_mod::deeper_mod::deep_fun();
diff --git a/sway-lsp/tests/fixtures/tokens/storage/Forc.toml b/sway-lsp/tests/fixtures/tokens/storage/Forc.toml
index fcd3c27e9bc..1c94244d129 100644
--- a/sway-lsp/tests/fixtures/tokens/storage/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/storage/Forc.toml
@@ -6,6 +6,4 @@ name = "storage"
 implicit-std = false
 
 [dependencies]
-# TODO: Temporarily use the local std before the tests dependencies are bumped to v0.54.1.
-# std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
-std = { path = "../../../../../sway-lib-std" }
\ No newline at end of file
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/structs/Forc.toml b/sway-lsp/tests/fixtures/tokens/structs/Forc.toml
index 80e834b458f..3cfadffb7a5 100644
--- a/sway-lsp/tests/fixtures/tokens/structs/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/structs/Forc.toml
@@ -6,4 +6,4 @@ name = "structs"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/turbofish/Forc.toml b/sway-lsp/tests/fixtures/tokens/turbofish/Forc.toml
index 60ec45aa96e..29fbc06118d 100644
--- a/sway-lsp/tests/fixtures/tokens/turbofish/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/turbofish/Forc.toml
@@ -6,4 +6,4 @@ name = "turbofish"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/variables/Forc.toml b/sway-lsp/tests/fixtures/tokens/variables/Forc.toml
index 4aff801020f..5876dbdf042 100644
--- a/sway-lsp/tests/fixtures/tokens/variables/Forc.toml
+++ b/sway-lsp/tests/fixtures/tokens/variables/Forc.toml
@@ -6,4 +6,4 @@ name = "variables"
 implicit-std = false
 
 [dependencies]
-std = { git = "https://github.com/FuelLabs/sway", tag = "v0.48.1" }
+std = { git = "https://github.com/FuelLabs/sway", tag = "v0.62.0" }
diff --git a/sway-lsp/tests/fixtures/tokens/variables/src/main.sw b/sway-lsp/tests/fixtures/tokens/variables/src/main.sw
index bc4ff864d22..53e7b929f3d 100644
--- a/sway-lsp/tests/fixtures/tokens/variables/src/main.sw
+++ b/sway-lsp/tests/fixtures/tokens/variables/src/main.sw
@@ -35,7 +35,7 @@ fn main() {
     let _ = (variable3, 20);
 
     // Variable usage: Array elements
-    let _ = [variable4, 20];
+    let _ = [variable4, ""];
 
     // Variable usage: Scoped Declarations
     {
diff --git a/sway-lsp/tests/integration/lsp.rs b/sway-lsp/tests/integration/lsp.rs
index e0d063871be..b187510b5fb 100644
--- a/sway-lsp/tests/integration/lsp.rs
+++ b/sway-lsp/tests/integration/lsp.rs
@@ -123,6 +123,51 @@ pub(crate) async fn did_change_request(
     did_change
 }
 
+/// Simulates a keypress at the current cursor position
+/// 66% chance of enter keypress
+/// 33% chance of backspace keypress
+pub fn simulate_keypress(
+    uri: &Url,
+    version: i32,
+    cursor_line: &mut u32,
+) -> DidChangeTextDocumentParams {
+    if rand::random::<u64>() % 3 < 2 {
+        // enter keypress at current cursor line
+        *cursor_line += 1;
+        create_did_change_params(
+            uri,
+            version,
+            Position {
+                line: *cursor_line - 1,
+                character: 0,
+            },
+            Position {
+                line: *cursor_line - 1,
+                character: 0,
+            },
+            0,
+        )
+    } else {
+        // backspace keypress at current cursor line
+        if *cursor_line > 1 {
+            *cursor_line -= 1;
+        }
+        create_did_change_params(
+            uri,
+            version,
+            Position {
+                line: *cursor_line,
+                character: 0,
+            },
+            Position {
+                line: *cursor_line + 1,
+                character: 0,
+            },
+            1,
+        )
+    }
+}
+
 pub(crate) async fn show_ast_request(
     server: &ServerState,
     uri: &Url,
@@ -276,6 +321,56 @@ pub(crate) async fn highlight_request(server: &ServerState, uri: &Url) {
     assert_eq!(expected, response.unwrap());
 }
 
+pub(crate) async fn references_request(server: &ServerState, uri: &Url) {
+    let params = ReferenceParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri: uri.clone() },
+            position: Position {
+                line: 15,
+                character: 22,
+            },
+        },
+        work_done_progress_params: Default::default(),
+        partial_result_params: Default::default(),
+        context: ReferenceContext {
+            include_declaration: false,
+        },
+    };
+
+    let create_location = |line: u32, start_char: u32, end_char: u32| -> Location {
+        Location {
+            uri: uri.clone(),
+            range: Range {
+                start: Position {
+                    line,
+                    character: start_char,
+                },
+                end: Position {
+                    line,
+                    character: end_char,
+                },
+            },
+        }
+    };
+
+    let mut response = request::handle_references(server, params)
+        .await
+        .unwrap()
+        .unwrap();
+
+    let mut expected = vec![
+        create_location(12, 7, 11),
+        create_location(15, 21, 25),
+        create_location(15, 14, 18),
+        create_location(13, 13, 17),
+        create_location(3, 5, 9),
+        create_location(14, 8, 12),
+    ];
+    response.sort_by(|a, b| a.range.start.cmp(&b.range.start));
+    expected.sort_by(|a, b| a.range.start.cmp(&b.range.start));
+    assert_eq!(expected, response);
+}
+
 pub(crate) async fn code_lens_empty_request(server: &ServerState, uri: &Url) {
     let params = CodeLensParams {
         text_document: TextDocumentIdentifier { uri: uri.clone() },
@@ -545,8 +640,8 @@ pub(crate) async fn rename_request<'a>(
         new_name: rename.new_name.to_string(),
         work_done_progress_params: Default::default(),
     };
-    let worspace_edit = request::handle_rename(server, params).await.unwrap();
-    worspace_edit.unwrap()
+    let workspace_edit = request::handle_rename(server, params).await.unwrap();
+    workspace_edit.unwrap()
 }
 
 pub fn create_did_change_params(
@@ -568,3 +663,126 @@ pub fn create_did_change_params(
         }],
     }
 }
+
+pub(crate) async fn inlay_hints_request<'a>(
+    server: &ServerState,
+    uri: &Url,
+) -> Option<Vec<InlayHint>> {
+    let params = InlayHintParams {
+        text_document: TextDocumentIdentifier { uri: uri.clone() },
+        range: Range {
+            start: Position {
+                line: 25,
+                character: 0,
+            },
+            end: Position {
+                line: 26,
+                character: 1,
+            },
+        },
+        work_done_progress_params: Default::default(),
+    };
+    let res = request::handle_inlay_hints(server, params)
+        .await
+        .unwrap()
+        .unwrap();
+    let expected = vec![
+        InlayHint {
+            position: Position {
+                line: 25,
+                character: 25,
+            },
+            label: InlayHintLabel::String("foo: ".to_string()),
+            kind: Some(InlayHintKind::PARAMETER),
+            text_edits: None,
+            tooltip: None,
+            padding_left: Some(false),
+            padding_right: Some(false),
+            data: None,
+        },
+        InlayHint {
+            position: Position {
+                line: 25,
+                character: 28,
+            },
+            label: InlayHintLabel::String("bar: ".to_string()),
+            kind: Some(InlayHintKind::PARAMETER),
+            text_edits: None,
+            tooltip: None,
+            padding_left: Some(false),
+            padding_right: Some(false),
+            data: None,
+        },
+        InlayHint {
+            position: Position {
+                line: 25,
+                character: 31,
+            },
+            label: InlayHintLabel::String("long_argument_name: ".to_string()),
+            kind: Some(InlayHintKind::PARAMETER),
+            text_edits: None,
+            tooltip: None,
+            padding_left: Some(false),
+            padding_right: Some(false),
+            data: None,
+        },
+        InlayHint {
+            position: Position {
+                line: 25,
+                character: 10,
+            },
+            label: InlayHintLabel::String(": u64".to_string()),
+            kind: Some(InlayHintKind::TYPE),
+            text_edits: None,
+            tooltip: None,
+            padding_left: Some(false),
+            padding_right: Some(false),
+            data: None,
+        },
+    ];
+
+    assert!(
+        compare_inlay_hint_vecs(&expected, &res),
+        "InlayHint vectors are not equal.\nExpected:\n{:#?}\n\nActual:\n{:#?}",
+        expected,
+        res
+    );
+    Some(res)
+}
+
+// This is a helper function to compare two inlay hints. because PartialEq is not implemented for InlayHint
+fn compare_inlay_hints(a: &InlayHint, b: &InlayHint) -> bool {
+    a.position == b.position
+        && compare_inlay_hint_labels(&a.label, &b.label)
+        && a.kind == b.kind
+        && a.text_edits == b.text_edits
+        && compare_inlay_hint_tooltips(&a.tooltip, &b.tooltip)
+        && a.padding_left == b.padding_left
+        && a.padding_right == b.padding_right
+        && a.data == b.data
+}
+
+fn compare_inlay_hint_vecs(a: &[InlayHint], b: &[InlayHint]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(a, b)| compare_inlay_hints(a, b))
+}
+
+fn compare_inlay_hint_labels(a: &InlayHintLabel, b: &InlayHintLabel) -> bool {
+    match (a, b) {
+        (InlayHintLabel::String(a), InlayHintLabel::String(b)) => a == b,
+        _ => false,
+    }
+}
+
+fn compare_inlay_hint_tooltips(a: &Option<InlayHintTooltip>, b: &Option<InlayHintTooltip>) -> bool {
+    match (a, b) {
+        (None, None) => true,
+        (Some(a), Some(b)) => match (a, b) {
+            (InlayHintTooltip::String(a), InlayHintTooltip::String(b)) => a == b,
+            (InlayHintTooltip::MarkupContent(a), InlayHintTooltip::MarkupContent(b)) => {
+                a.kind == b.kind && a.value == b.value
+            }
+            _ => false,
+        },
+        _ => false,
+    }
+}
diff --git a/sway-lsp/tests/lib.rs b/sway-lsp/tests/lib.rs
index 77727dbeb1a..c377db53bf5 100644
--- a/sway-lsp/tests/lib.rs
+++ b/sway-lsp/tests/lib.rs
@@ -1,9 +1,13 @@
+#![recursion_limit = "256"]
+
 pub mod integration;
 
 use crate::integration::{code_actions, lsp};
 use lsp_types::*;
-use std::{fs, path::PathBuf};
+use rayon::prelude::*;
+use std::{fs, panic, path::PathBuf, process::Command, sync::Mutex};
 use sway_lsp::{
+    config::LspClient,
     handlers::{notification, request},
     server_state::ServerState,
 };
@@ -66,7 +70,7 @@ async fn init_and_open(service: &mut LspService<ServerState>, entry_point: PathB
     uri
 }
 
-async fn shutdown_and_exit(service: &mut LspService<ServerState>) {
+pub async fn shutdown_and_exit(service: &mut LspService<ServerState>) {
     let _ = lsp::shutdown_request(service).await;
     lsp::exit_notification(service).await;
 }
@@ -219,9 +223,12 @@ fn did_change_stress_test_random_wait() {
                 .join("generics_in_contract");
             let uri = init_and_open(&mut service, example_dir.join("src/main.sw")).await;
             let times = 60;
+
+            // Initialize cursor position
+            let mut cursor_line = 29;
             for version in 0..times {
-                //eprintln!("version: {}", version);
-                let _ = lsp::did_change_request(&mut service, &uri, version + 1, None).await;
+                let params = lsp::simulate_keypress(&uri, version, &mut cursor_line);
+                let _ = lsp::did_change_request(&mut service, &uri, version, Some(params)).await;
                 if version == 0 {
                     service.inner().wait_for_parsing().await;
                 }
@@ -251,77 +258,6 @@ fn did_change_stress_test_random_wait() {
     });
 }
 
-fn garbage_collection_runner(path: PathBuf) {
-    run_async!({
-        setup_panic_hook();
-        let (mut service, _) = LspService::new(ServerState::new);
-        // set the garbage collection frequency to 1
-        service
-            .inner()
-            .config
-            .write()
-            .garbage_collection
-            .gc_frequency = 1;
-        let uri = init_and_open(&mut service, path).await;
-        let times = 60;
-        for version in 1..times {
-            //eprintln!("version: {}", version);
-            let params = if rand::random::<u64>() % 3 < 1 {
-                // enter keypress at line 20
-                lsp::create_did_change_params(
-                    &uri,
-                    version,
-                    Position {
-                        line: 20,
-                        character: 0,
-                    },
-                    Position {
-                        line: 20,
-                        character: 0,
-                    },
-                    0,
-                )
-            } else {
-                // backspace keypress at line 21
-                lsp::create_did_change_params(
-                    &uri,
-                    version,
-                    Position {
-                        line: 20,
-                        character: 0,
-                    },
-                    Position {
-                        line: 21,
-                        character: 0,
-                    },
-                    1,
-                )
-            };
-            let _ = lsp::did_change_request(&mut service, &uri, version, Some(params)).await;
-            if version == 0 {
-                service.inner().wait_for_parsing().await;
-            }
-            // wait for a random amount of time to simulate typing
-            random_delay().await;
-        }
-        shutdown_and_exit(&mut service).await;
-    });
-}
-
-#[test]
-fn garbage_collection_storage() {
-    let p = sway_workspace_dir()
-        .join("sway-lsp/tests/fixtures/garbage_collection/storage_contract")
-        .join("src/main.sw");
-    garbage_collection_runner(p);
-}
-
-#[test]
-fn garbage_collection_paths() {
-    let p = test_fixtures_dir().join("tokens/paths/src/main.sw");
-    garbage_collection_runner(p);
-}
-
 #[test]
 fn lsp_syncs_with_workspace_edits() {
     run_async!({
@@ -413,7 +349,7 @@ fn go_to_definition_for_fields() {
             req_uri: &uri,
             req_line: 5,
             req_char: 8,
-            def_line: 81,
+            def_line: 82,
             def_start_char: 9,
             def_end_char: 15,
             def_path: "sway-lib-std/src/option.sw",
@@ -470,7 +406,7 @@ fn go_to_definition_inside_turbofish() {
             req_uri: &uri,
             req_line: 15,
             req_char: 12,
-            def_line: 81,
+            def_line: 82,
             def_start_char: 9,
             def_end_char: 15,
             def_path: "sway-lib-std/src/option.sw",
@@ -490,7 +426,7 @@ fn go_to_definition_inside_turbofish() {
             req_uri: &uri,
             req_line: 20,
             req_char: 19,
-            def_line: 61,
+            def_line: 62,
             def_start_char: 9,
             def_end_char: 15,
             def_path: "sway-lib-std/src/result.sw",
@@ -550,7 +486,7 @@ fn go_to_definition_for_matches() {
             req_uri: &uri,
             req_line: 25,
             req_char: 19,
-            def_line: 81,
+            def_line: 82,
             def_start_char: 9,
             def_end_char: 15,
             def_path: "sway-lib-std/src/option.sw",
@@ -568,7 +504,7 @@ fn go_to_definition_for_matches() {
             req_uri: &uri,
             req_line: 25,
             req_char: 27,
-            def_line: 85,
+            def_line: 86,
             def_start_char: 4,
             def_end_char: 8,
             def_path: "sway-lib-std/src/option.sw",
@@ -583,7 +519,7 @@ fn go_to_definition_for_matches() {
             req_uri: &uri,
             req_line: 26,
             req_char: 17,
-            def_line: 83,
+            def_line: 84,
             def_start_char: 4,
             def_end_char: 8,
             def_path: "sway-lib-std/src/option.sw",
@@ -685,8 +621,8 @@ fn go_to_definition_for_paths() {
         // std
         lsp::definition_check(&server, &go_to).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 12, 14).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 18, 5).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 24, 13).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 16, 5).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 22, 13).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 7, 5).await;
 
         let go_to = GotoDefinition {
@@ -705,7 +641,7 @@ fn go_to_definition_for_paths() {
             req_uri: &uri,
             req_line: 10,
             req_char: 27,
-            def_line: 81,
+            def_line: 82,
             def_start_char: 9,
             def_end_char: 15,
             def_path: "sway-lib-std/src/option.sw",
@@ -754,7 +690,7 @@ fn go_to_definition_for_paths() {
             req_uri: &uri,
             req_line: 12,
             req_char: 42,
-            def_line: 7,
+            def_line: 8,
             def_start_char: 11,
             def_end_char: 21,
             def_path: "sway-lib-std/src/vm/evm/evm_address.sw",
@@ -764,7 +700,7 @@ fn go_to_definition_for_paths() {
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 16,
+            req_line: 14,
             req_char: 6,
             def_line: 0,
             def_start_char: 0,
@@ -773,12 +709,12 @@ fn go_to_definition_for_paths() {
         };
         // test_mod
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 22, 7).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 20, 7).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 5, 5).await;
 
         let go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 16,
+            req_line: 14,
             req_char: 16,
             def_line: 2,
             def_start_char: 7,
@@ -790,7 +726,7 @@ fn go_to_definition_for_paths() {
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 17,
+            req_line: 15,
             req_char: 8,
             def_line: 0,
             def_start_char: 0,
@@ -800,16 +736,16 @@ fn go_to_definition_for_paths() {
         // deep_mod
         lsp::definition_check(&server, &go_to).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 6, 6).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 25, 16).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 26, 16).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 27, 16).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 28, 16).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 29, 16).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 30, 16).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 32, 16).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 33, 16).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 31, 16).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 17,
+            req_line: 15,
             req_char: 18,
             def_line: 0,
             def_start_char: 0,
@@ -819,16 +755,16 @@ fn go_to_definition_for_paths() {
         // deeper_mod
         lsp::definition_check(&server, &go_to).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 6, 16).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 25, 28).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 26, 28).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 27, 28).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 28, 28).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 29, 28).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 30, 28).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 32, 28).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 33, 28).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 31, 28).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 27,
+            req_line: 25,
             req_char: 38,
             def_line: 4,
             def_start_char: 9,
@@ -837,13 +773,13 @@ fn go_to_definition_for_paths() {
         };
         // DeepEnum
         lsp::definition_check(&server, &go_to).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 26, 38).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 27, 38).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 28, 38).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 29, 38).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 30, 38).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 32,
+            req_line: 30,
             req_char: 37,
             def_line: 9,
             def_start_char: 11,
@@ -852,11 +788,11 @@ fn go_to_definition_for_paths() {
         };
         // DeepStruct
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 33, 37).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 31, 37).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 27,
+            req_line: 25,
             req_char: 48,
             def_line: 5,
             def_start_char: 4,
@@ -865,11 +801,11 @@ fn go_to_definition_for_paths() {
         };
         // DeepEnum::Variant
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 28, 48).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 26, 48).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 29,
+            req_line: 27,
             req_char: 48,
             def_line: 6,
             def_start_char: 4,
@@ -878,11 +814,11 @@ fn go_to_definition_for_paths() {
         };
         // DeepEnum::Number
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 30, 48).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 28, 48).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 17,
+            req_line: 15,
             req_char: 29,
             def_line: 2,
             def_start_char: 7,
@@ -895,7 +831,7 @@ fn go_to_definition_for_paths() {
 
         let go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 18,
+            req_line: 16,
             req_char: 11,
             def_line: 0,
             def_start_char: 0,
@@ -907,20 +843,32 @@ fn go_to_definition_for_paths() {
 
         let go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 19,
+            req_line: 31,
             req_char: 13,
             def_line: 0,
             def_start_char: 0,
             def_end_char: 0,
-            def_path: "sway-lib-core/src/lib.sw",
+            def_path: "sway-lsp/tests/fixtures/tokens/paths/src/deep_mod.sw",
         };
         // core
         lsp::definition_check(&server, &go_to).await;
 
-        let mut go_to = GotoDefinition {
+        let go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 19,
-            req_char: 21,
+            req_line: 31,
+            req_char: 26,
+            def_line: 0,
+            def_start_char: 0,
+            def_end_char: 0,
+            def_path: "sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw",
+        };
+        // primitives
+        lsp::definition_check(&server, &go_to).await;
+
+        let go_to = GotoDefinition {
+            req_uri: &uri,
+            req_line: 23,
+            req_char: 20,
             def_line: 0,
             def_start_char: 0,
             def_end_char: 0,
@@ -928,7 +876,6 @@ fn go_to_definition_for_paths() {
         };
         // primitives
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 25, 20).await;
 
         let go_to = GotoDefinition {
             req_uri: &uri,
@@ -944,7 +891,7 @@ fn go_to_definition_for_paths() {
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 21,
+            req_line: 19,
             req_char: 4,
             def_line: 4,
             def_start_char: 11,
@@ -953,11 +900,11 @@ fn go_to_definition_for_paths() {
         };
         // A impl
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 22, 14).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 20, 14).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 21,
+            req_line: 19,
             req_char: 7,
             def_line: 7,
             def_start_char: 11,
@@ -966,11 +913,11 @@ fn go_to_definition_for_paths() {
         };
         // fun
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 22, 18).await;
+        lsp::definition_check_with_req_offset(&server, &mut go_to, 20, 18).await;
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 24,
+            req_line: 22,
             req_char: 20,
             def_line: 0,
             def_start_char: 0,
@@ -984,9 +931,9 @@ fn go_to_definition_for_paths() {
 
         let mut go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 24,
+            req_line: 22,
             req_char: 31,
-            def_line: 33,
+            def_line: 19,
             def_start_char: 10,
             def_end_char: 19,
             def_path: "sway-lib-std/src/constants.sw",
@@ -997,9 +944,9 @@ fn go_to_definition_for_paths() {
 
         let go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 19,
+            req_line: 17,
             req_char: 37,
-            def_line: 74,
+            def_line: 92,
             def_start_char: 11,
             def_end_char: 14,
             def_path: "sway-lib-core/src/primitives.sw",
@@ -1007,31 +954,29 @@ fn go_to_definition_for_paths() {
         // u64::min()
         lsp::definition_check(&server, &go_to).await;
 
-        let mut go_to = GotoDefinition {
+        let go_to = GotoDefinition {
             req_uri: &uri,
-            req_line: 13,
-            req_char: 22,
-            def_line: 304,
+            req_line: 23,
+            req_char: 37,
+            def_line: 392,
             def_start_char: 11,
             def_end_char: 14,
             def_path: "sway-lib-core/src/primitives.sw",
         };
         // b256::min()
         lsp::definition_check(&server, &go_to).await;
-        lsp::definition_check_with_req_offset(&server, &mut go_to, 25, 38).await;
-
-        // TODO: Uncomment when https://github.com/FuelLabs/sway/issues/4211 is fixed.
-        // let go_to = GotoDefinition {
-        //     req_uri: &uri,
-        //     req_line: 6,
-        //     req_char: 39,
-        //     def_line: 2,
-        //     def_start_char: 7,
-        //     def_end_char: 15,
-        //     def_path: "sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw",
-        // };
+
+        let go_to = GotoDefinition {
+            req_uri: &uri,
+            req_line: 6,
+            req_char: 39,
+            def_line: 2,
+            def_start_char: 7,
+            def_end_char: 15,
+            def_path: "sway-lsp/tests/fixtures/tokens/paths/src/deep_mod/deeper_mod.sw",
+        };
         // dfun
-        // lsp::definition_check(&server, &go_to).await;
+        lsp::definition_check(&server, &go_to).await;
 
         let _ = server.shutdown_server();
     });
@@ -1135,14 +1080,14 @@ fn go_to_definition_for_variables() {
         lsp::definition_check_with_req_offset(&server, &mut go_to, 53, 21).await;
 
         // Complex type ascriptions
-        go_to.def_line = 61;
+        go_to.def_line = 62;
         go_to.def_start_char = 9;
         go_to.def_end_char = 15;
         go_to.def_path = "sway-lib-std/src/result.sw";
         lsp::definition_check_with_req_offset(&server, &mut go_to, 56, 22).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 11, 31).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 11, 60).await;
-        go_to.def_line = 81;
+        go_to.def_line = 82;
         go_to.def_path = "sway-lib-std/src/option.sw";
         lsp::definition_check_with_req_offset(&server, &mut go_to, 56, 28).await;
         lsp::definition_check_with_req_offset(&server, &mut go_to, 11, 39).await;
@@ -1176,7 +1121,7 @@ fn go_to_definition_for_consts() {
             req_uri: &uri,
             req_line: 9,
             req_char: 24,
-            def_line: 8,
+            def_line: 7,
             def_start_char: 11,
             def_end_char: 21,
             def_path: "sway-lib-std/src/contract_id.sw",
@@ -1184,7 +1129,7 @@ fn go_to_definition_for_consts() {
         lsp::definition_check(&server, &contract_go_to).await;
 
         contract_go_to.req_char = 34;
-        contract_go_to.def_line = 40;
+        contract_go_to.def_line = 56;
         contract_go_to.def_start_char = 7;
         contract_go_to.def_end_char = 11;
         lsp::definition_check(&server, &contract_go_to).await;
@@ -1228,7 +1173,7 @@ fn go_to_definition_for_consts() {
         lsp::definition_check_with_req_offset(&server, &mut go_to, 10, 17).await;
 
         // Complex type ascriptions
-        go_to.def_line = 81;
+        go_to.def_line = 82;
         go_to.def_start_char = 9;
         go_to.def_end_char = 15;
         go_to.def_path = "sway-lib-std/src/option.sw";
@@ -1323,7 +1268,7 @@ fn go_to_definition_for_structs() {
             req_uri: &uri,
             req_line: 16,
             req_char: 11,
-            def_line: 81,
+            def_line: 82,
             def_start_char: 9,
             def_end_char: 15,
             def_path: "sway-lib-std/src/option.sw",
@@ -1635,9 +1580,10 @@ fn hover_docs_for_consts() {
 }
 
 #[test]
-fn hover_docs_for_functions() {
+fn hover_docs_for_functions_vscode() {
     run_async!({
         let server = ServerState::default();
+        server.config.write().client = LspClient::VsCode;
         let uri = open(
             &server,
             test_fixtures_dir().join("tokens/functions/src/main.sw"),
@@ -1779,17 +1725,18 @@ fn hover_docs_with_code_examples() {
 }
 
 #[test]
-fn hover_docs_for_self_keywords() {
+fn hover_docs_for_self_keywords_vscode() {
     run_async!({
         let server = ServerState::default();
+        server.config.write().client = LspClient::VsCode;
         let uri = open(&server, test_fixtures_dir().join("completion/src/main.sw")).await;
 
         let mut hover = HoverDocumentation {
-        req_uri: &uri,
-        req_line: 11,
-        req_char: 13,
-        documentation: vec!["\n```sway\nself\n```\n\n---\n\n The receiver of a method, or the current module.\n\n `self` is used in two situations: referencing the current module and marking\n the receiver of a method.\n\n In paths, `self` can be used to refer to the current module, either in a\n [`use`] statement or in a path to access an element:\n\n ```sway\n use std::contract_id::{self, ContractId};\n ```\n\n Is functionally the same as:\n\n ```sway\n use std::contract_id;\n use std::contract_id::ContractId;\n ```\n\n `self` as the current receiver for a method allows to omit the parameter\n type most of the time. With the exception of this particularity, `self` is\n used much like any other parameter:\n\n ```sway\n struct Foo(u32);\n\n impl Foo {\n     // No `self`.\n     fn new() -> Self {\n         Self(0)\n     }\n\n     // Borrowing `self`.\n     fn value(&self) -> u32 {\n         self.0\n     }\n\n     // Updating `self` mutably.\n     fn clear(ref mut self) {\n         self.0 = 0\n     }\n }\n ```"],
-    };
+            req_uri: &uri,
+            req_line: 11,
+            req_char: 13,
+            documentation: vec!["\n```sway\nself\n```\n\n---\n\n The receiver of a method, or the current module.\n\n `self` is used in two situations: referencing the current module and marking\n the receiver of a method.\n\n In paths, `self` can be used to refer to the current module, either in a\n [`use`] statement or in a path to access an element:\n\n ```sway\n use std::contract_id::{self, ContractId};\n ```\n\n Is functionally the same as:\n\n ```sway\n use std::contract_id;\n use std::contract_id::ContractId;\n ```\n\n `self` as the current receiver for a method allows to omit the parameter\n type most of the time. With the exception of this particularity, `self` is\n used much like any other parameter:\n\n ```sway\n struct Foo(u32);\n\n impl Foo {\n     // No `self`.\n     fn new() -> Self {\n         Self(0)\n     }\n\n     // Borrowing `self`.\n     fn value(&self) -> u32 {\n         self.0\n     }\n\n     // Updating `self` mutably.\n     fn clear(ref mut self) {\n         self.0 = 0\n     }\n }\n ```"],
+        };
 
         lsp::hover_request(&server, &hover).await;
         hover.req_char = 24;
@@ -1799,6 +1746,24 @@ fn hover_docs_for_self_keywords() {
     });
 }
 
+#[test]
+fn hover_docs_for_self_keywords() {
+    run_async!({
+        let server = ServerState::default();
+        let uri = open(&server, test_fixtures_dir().join("completion/src/main.sw")).await;
+
+        let hover = HoverDocumentation {
+            req_uri: &uri,
+            req_line: 11,
+            req_char: 13,
+            documentation: vec!["\n```sway\nself\n```\n\n---\n\n The receiver of a method, or the current module.\n\n `self` is used in two situations: referencing the current module and marking\n the receiver of a method.\n\n In paths, `self` can be used to refer to the current module, either in a\n [`use`] statement or in a path to access an element:\n\n ```sway\n use std::contract_id::{self, ContractId};\n ```\n\n Is functionally the same as:\n\n ```sway\n use std::contract_id;\n use std::contract_id::ContractId;\n ```\n\n `self` as the current receiver for a method allows to omit the parameter\n type most of the time. With the exception of this particularity, `self` is\n used much like any other parameter:\n\n ```sway\n struct Foo(u32);\n\n impl Foo {\n     // No `self`.\n     fn new() -> Self {\n         Self(0)\n     }\n\n     // Borrowing `self`.\n     fn value(&self) -> u32 {\n         self.0\n     }\n\n     // Updating `self` mutably.\n     fn clear(ref mut self) {\n         self.0 = 0\n     }\n }\n ```"],
+        };
+
+        lsp::hover_request(&server, &hover).await;
+        let _ = server.shutdown_server();
+    });
+}
+
 #[test]
 fn hover_docs_for_boolean_keywords() {
     run_async!({
@@ -2000,6 +1965,11 @@ lsp_capability_test!(
     lsp::highlight_request,
     doc_comments_dir().join("src/main.sw")
 );
+lsp_capability_test!(
+    references,
+    lsp::references_request,
+    test_fixtures_dir().join("tokens/structs/src/main.sw")
+);
 lsp_capability_test!(
     code_action_abi,
     code_actions::code_action_abi_request,
@@ -2075,6 +2045,11 @@ lsp_capability_test!(
     lsp::completion_request,
     test_fixtures_dir().join("completion/src/main.sw")
 );
+lsp_capability_test!(
+    inlay_hints_function_params,
+    lsp::inlay_hints_request,
+    test_fixtures_dir().join("inlay_hints/src/main.sw")
+);
 
 // This method iterates over all of the examples in the e2e language should_pass dir
 // and saves the lexed, parsed, and typed ASTs to the users home directory.
@@ -2128,3 +2103,198 @@ async fn write_all_example_asts() {
     }
     let _ = server.shutdown_server();
 }
+
+#[test]
+fn test_url_to_session_existing_session() {
+    use std::sync::Arc;
+    run_async!({
+        let (mut service, _) = LspService::new(ServerState::new);
+        let uri = init_and_open(&mut service, doc_comments_dir().join("src/main.sw")).await;
+
+        // First call to uri_and_session_from_workspace
+        let (first_uri, first_session) = service
+            .inner()
+            .uri_and_session_from_workspace(&uri)
+            .await
+            .unwrap();
+
+        // Second call to uri_and_session_from_workspace
+        let (second_uri, second_session) = service
+            .inner()
+            .uri_and_session_from_workspace(&uri)
+            .await
+            .unwrap();
+
+        // Assert that the URIs are the same
+        assert_eq!(first_uri, second_uri, "URIs should be identical");
+
+        // Assert that the sessions are the same (they should point to the same Arc)
+        assert!(
+            Arc::ptr_eq(&first_session, &second_session),
+            "Sessions should be identical"
+        );
+        shutdown_and_exit(&mut service).await;
+    });
+}
+
+//------------------- GARBAGE COLLECTION TESTS -------------------//
+
+async fn garbage_collection_runner(path: PathBuf) {
+    setup_panic_hook();
+    let (mut service, _) = LspService::new(ServerState::new);
+    let uri = init_and_open(&mut service, path).await;
+    let times = 20;
+
+    // Initialize cursor position
+    let mut cursor_line = 1;
+
+    for version in 1..times {
+        //eprintln!("version: {}", version);
+        let params = lsp::simulate_keypress(&uri, version, &mut cursor_line);
+        let _ = lsp::did_change_request(&mut service, &uri, version, Some(params)).await;
+        if version == 0 {
+            service.inner().wait_for_parsing().await;
+        }
+        // wait for a random amount of time to simulate typing
+        random_delay().await;
+    }
+    shutdown_and_exit(&mut service).await;
+}
+
+#[test]
+fn garbage_collection_storage() {
+    let p = sway_workspace_dir()
+        .join("sway-lsp/tests/fixtures/garbage_collection/storage_contract")
+        .join("src/main.sw");
+    run_async!({
+        garbage_collection_runner(p).await;
+    });
+}
+
+#[test]
+fn garbage_collection_paths() {
+    let p = test_fixtures_dir().join("tokens/paths/src/main.sw");
+    run_async!({
+        garbage_collection_runner(p).await;
+    });
+}
+
+#[test]
+fn garbage_collection_minimal_script() {
+    let p = sway_workspace_dir()
+        .join("sway-lsp/tests/fixtures/garbage_collection/minimal_script")
+        .join("src/main.sw");
+    run_async!({
+        garbage_collection_runner(p).await;
+    });
+}
+
+/// Tests garbage collection across all language test examples in parallel.
+///
+/// # Overview
+/// This test suite takes a unique approach to handling test isolation and error reporting:
+///
+/// 1. Process Isolation: Each test is run in its own process to ensure complete isolation
+///    between test runs. This allows us to catch all failures rather than stopping at
+///    the first panic or error.
+///
+/// 2. Parallel Execution: Uses rayon to run tests concurrently, significantly reducing
+///    total test time from several minutes to under a minute.
+///
+/// 3. Full Coverage: Unlike traditional test approaches that stop at the first failure,
+///    this runner continues through all tests, providing a complete picture of which
+///    examples need garbage collection fixes.
+///
+/// # Implementation Details
+/// - Uses std::process::Command to spawn each test in isolation
+/// - Collects results through a thread-safe Mutex
+/// - Provides detailed error reporting for failed tests
+/// - Categorizes different types of failures (exit codes vs signals)
+// #[test]
+#[allow(dead_code)]
+fn run_all_garbage_collection_tests() {
+    let base_dir = sway_workspace_dir().join(e2e_language_dir());
+    let entries: Vec<_> = std::fs::read_dir(base_dir)
+        .unwrap()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_type().map(|ft| ft.is_dir()).unwrap_or(false))
+        .collect();
+
+    let results = Mutex::new(Vec::new());
+
+    println!("\n=== Starting Garbage Collection Tests ===\n");
+
+    entries.par_iter().for_each(|entry| {
+        let project_dir = entry.path();
+        let project_name = project_dir
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .to_string();
+        let main_file = project_dir.join("src/main.sw");
+
+        println!("▶ Testing: {}", project_name);
+        println!("  Path: {}", main_file.display());
+
+        let status = Command::new(std::env::current_exe().unwrap())
+            .args(["--test", "test_single_project", "--exact", "--nocapture"])
+            .env("TEST_FILE", main_file.to_string_lossy().to_string())
+            .status()
+            .unwrap();
+
+        let test_result = if status.success() {
+            println!("  ✅ Passed: {}\n", project_name);
+            (project_name, true, None)
+        } else {
+            println!("  ❌ Failed: {} ({})\n", project_name, status);
+            (project_name, false, Some(format!("Exit code: {}", status)))
+        };
+
+        results.lock().unwrap().push(test_result);
+    });
+
+    let results = results.into_inner().unwrap();
+
+    // Print final results
+    println!("=== Garbage Collection Test Results ===\n");
+
+    let total = results.len();
+    let passed = results.iter().filter(|r| r.1).count();
+    let failed = total - passed;
+
+    println!("Total tests:  {}", total);
+    println!("✅ Passed:    {}", passed);
+    println!("❌ Failed:    {}", failed);
+
+    if failed > 0 {
+        println!("\nFailed Projects:");
+        for (name, _, error) in results.iter().filter(|r| !r.1) {
+            println!("- {} (Error: {})", name, error.as_ref().unwrap());
+        }
+
+        panic!("{} projects failed garbage collection testing", failed);
+    }
+}
+
+/// Individual test runner executed in a separate process for each test.
+///
+/// This function is called by the main test runner through a new process invocation
+/// for each test file. The file path is passed via the TEST_FILE environment
+/// variable to maintain process isolation.
+///
+/// # Process Isolation
+/// Running each test in its own process ensures that:
+/// 1. Tests are completely isolated from each other
+/// 2. Panics in one test don't affect others
+/// 3. Resource cleanup happens automatically on process exit
+// #[tokio::test]
+#[allow(dead_code)]
+async fn test_single_project() {
+    if let Ok(file) = std::env::var("TEST_FILE") {
+        println!("Running single test for file: {}", file);
+        let path = PathBuf::from(file);
+        garbage_collection_runner(path).await;
+    } else {
+        panic!("TEST_FILE environment variable not set");
+    }
+}
diff --git a/sway-lsp/tests/nextest.toml b/sway-lsp/tests/nextest.toml
new file mode 100644
index 00000000000..6719d7f0200
--- /dev/null
+++ b/sway-lsp/tests/nextest.toml
@@ -0,0 +1,6 @@
+[profile.ci]
+retries = 0
+
+[[profile.ci.overrides]]
+filter = 'test(go_to_definition_for_paths)'
+retries = 2
diff --git a/sway-lsp/tests/utils/Cargo.toml b/sway-lsp/tests/utils/Cargo.toml
index 1901ec8c701..cbb98baae8e 100644
--- a/sway-lsp/tests/utils/Cargo.toml
+++ b/sway-lsp/tests/utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-lsp-test-utils"
-version = "0.1.0"
+version.workspace = true
 description = "Test utils for the Sway LSP Server."
 publish = false
 authors.workspace = true
@@ -9,13 +9,16 @@ homepage.workspace = true
 license.workspace = true
 repository.workspace = true
 
+[package.metadata.cargo-udeps.ignore]
+normal = ["tower"]
+
 [dependencies]
-assert-json-diff = "2.0"
-futures = { version = "0.3", default-features = false, features = ["std", "async-await"] }
-lsp-types = { version = "0.94", features = ["proposed"] }
-rand = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.60"
-tokio = { version = "1.3", features = ["io-std", "io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }
-tower = { version = "0.4.12", default-features = false, features = ["util"] }
-tower-lsp = { version = "0.20", features = ["proposed"] }
+assert-json-diff.workspace = true
+futures = { workspace = true, features = ["async-await", "std"] }
+lsp-types = { workspace = true, features = ["proposed"] }
+rand.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+tokio = { workspace = true, features = ["io-util", "io-std", "macros", "net", "rt-multi-thread", "sync", "time"] }
+tower = { workspace = true, features = ["util"] }
+tower-lsp = { workspace = true, features = ["proposed"] }
diff --git a/sway-lsp/tests/utils/src/lib.rs b/sway-lsp/tests/utils/src/lib.rs
index 3124481ca06..be741f8798b 100644
--- a/sway-lsp/tests/utils/src/lib.rs
+++ b/sway-lsp/tests/utils/src/lib.rs
@@ -1,7 +1,7 @@
 use assert_json_diff::assert_json_include;
 use futures::StreamExt;
 use lsp_types::Url;
-use rand::Rng;
+use rand::{rngs::SmallRng, Rng, SeedableRng};
 use serde_json::Value;
 use std::{
     env, fs,
@@ -117,23 +117,16 @@ pub async fn assert_server_requests(
 
 /// Introduces a random delay between 1 to 30 milliseconds with a chance of additional longer delays based on predefined probabilities.
 pub async fn random_delay() {
+    // Create a thread-safe RNG
+    let mut rng = SmallRng::from_entropy();
+
     // wait for a random amount of time between 1-30ms
-    tokio::time::sleep(tokio::time::Duration::from_millis(
-        rand::thread_rng().gen_range(1..=30),
-    ))
-    .await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(rng.gen_range(1..=30))).await;
 
-    // there is a 10% chance that a longer 100-800ms wait will be added
-    if rand::thread_rng().gen_ratio(1, 10) {
-        tokio::time::sleep(tokio::time::Duration::from_millis(
-            rand::thread_rng().gen_range(100..=1200),
-        ))
-        .await;
-    }
-    // 20% chance to introduce a longer delay of 200 to 1500 milliseconds.
-    if rand::thread_rng().gen_ratio(2, 10) {
+    // 20% chance to introduce a longer delay of 100 to 1200 milliseconds.
+    if rng.gen_ratio(2, 10) {
         tokio::time::sleep(tokio::time::Duration::from_millis(
-            rand::thread_rng().gen_range(400..=2800),
+            rng.gen_range(100..=1200),
         ))
         .await;
     }
diff --git a/sway-parse/Cargo.toml b/sway-parse/Cargo.toml
index e6fd6140362..eb7ebbc150c 100644
--- a/sway-parse/Cargo.toml
+++ b/sway-parse/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-parse"
-version = "0.60.0"
+version.workspace = true
 description = "Sway's parser"
 authors.workspace = true
 edition.workspace = true
@@ -9,16 +9,16 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-extension-trait = "1.0.1"
-num-bigint = "0.4.3"
-num-traits = "0.2.14"
-phf = { version = "0.10.1", features = ["macros"] }
-sway-ast = { version = "0.60.0", path = "../sway-ast" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-thiserror = "1.0"
-unicode-bidi = "0.3.13"
-unicode-xid = "0.2.2"
+extension-trait.workspace = true
+num-bigint.workspace = true
+num-traits.workspace = true
+phf = { workspace = true, features = ["macros"] }
+sway-ast.workspace = true
+sway-error.workspace = true
+sway-types.workspace = true
+thiserror.workspace = true
+unicode-bidi.workspace = true
+unicode-xid.workspace = true
 
 [dev-dependencies]
 assert_matches = "1.5.0"
diff --git a/sway-parse/src/brackets.rs b/sway-parse/src/brackets.rs
index 399c1b0cb65..02e990355f7 100644
--- a/sway-parse/src/brackets.rs
+++ b/sway-parse/src/brackets.rs
@@ -105,6 +105,7 @@ impl_brackets!(SquareBrackets, Bracket, ExpectedOpenBracket);
 #[derive(Clone, Debug)]
 pub struct AngleBrackets<T> {
     pub open_angle_bracket_token: OpenAngleBracketToken,
+    #[allow(unused)]
     pub inner: T,
     pub close_angle_bracket_token: CloseAngleBracketToken,
 }
diff --git a/sway-parse/src/expr/op_code.rs b/sway-parse/src/expr/op_code.rs
index c2742da33e9..1281ca4bae3 100644
--- a/sway-parse/src/expr/op_code.rs
+++ b/sway-parse/src/expr/op_code.rs
@@ -6,6 +6,10 @@ use sway_types::{Ident, Spanned};
 
 macro_rules! define_op_codes (
     ( $(($op_name:ident, $ty_name:ident, $s:literal, ($($arg_name:ident),*)),)* ) => {
+        pub const OP_CODES: &'static [&'static str] = &[
+            $($s),*
+        ];
+
         pub fn parse_instruction(ident: Ident, parser: &mut Parser) -> ParseResult<Instruction> {
             match ident.as_str() {
                 $($s => {
@@ -16,7 +20,9 @@ macro_rules! define_op_codes (
                 },)*
                 _ => {
                     let span = ident.span().clone();
-                    Err(parser.emit_error_with_span(ParseErrorKind::UnrecognizedOpCode, span))
+                    Err(parser.emit_error_with_span(ParseErrorKind::UnrecognizedOpCode {
+                        known_op_codes: OP_CODES,
+                    }, span))
                 },
             }
         }
@@ -54,6 +60,13 @@ define_op_codes!(
     (Srli, SrliOpcode, "srli", (ret, lhs, rhs)),
     (Sub, SubOpcode, "sub", (ret, lhs, rhs)),
     (Subi, SubiOpcode, "subi", (ret, lhs, rhs)),
+    (Wqcm, WqcmOpcode, "wqcm", (ret, lhs, rhs, op_mode)),
+    (Wqop, WqopOpcode, "wqop", (ret, lhs, rhs, op_mode)),
+    (Wqml, WqmlOpcode, "wqml", (ret, lhs, rhs, indirect)),
+    (Wqdv, WqdvOpcode, "wqdv", (ret, lhs, rhs, indirect)),
+    (Wqmd, WqmdOpcode, "wqmd", (ret, lhs_a, lhs_b, rhs)),
+    (Wqam, WqamOpcode, "wqam", (ret, lhs_a, lhs_b, rhs)),
+    (Wqmm, WqmmOpcode, "wqmm", (ret, lhs_a, lhs_b, rhs)),
     (Xor, XorOpcode, "xor", (ret, lhs, rhs)),
     (Xori, XoriOpcode, "xori", (ret, lhs, rhs)),
     /* Control Flow Instructions */
@@ -88,7 +101,9 @@ define_op_codes!(
     (Ccp, CcpOpcode, "ccp", (dst_addr, contract, src_addr, size)),
     (Croo, CrooOpcode, "croo", (addr, contract)),
     (Csiz, CsizOpcode, "csiz", (ret, contract)),
-    (Ldc, LdcOpcode, "ldc", (contract, addr, size)),
+    (Bsiz, BsizOpcode, "bsiz", (ret, contract)),
+    (Ldc, LdcOpcode, "ldc", (contract, addr, size, imm)),
+    (Bldd, BlddOpcode, "bldd", (dst_ptr, addr, offset, len)),
     (Log, LogOpcode, "log", (reg_a, reg_b, reg_c, reg_d)),
     (Logd, LogdOpcode, "logd", (reg_a, reg_b, addr, size)),
     (Mint, MintOpcode, "mint", (coins, sub_id)),
@@ -106,7 +121,7 @@ define_op_codes!(
     /* Cryptographic Instructions */
     (Eck1, Eck1Opcode, "eck1", (addr, sig, hash)),
     (Ecr1, Ecr1Opcode, "ecr1", (addr, sig, hash)),
-    (Ed19, Ed19Opcode, "ed19", (addr, sig, hash)),
+    (Ed19, Ed19Opcode, "ed19", (addr, sig, hash, len)),
     (K256, K256Opcode, "k256", (addr, data, size)),
     (S256, S256Opcode, "s256", (addr, data, size)),
     /* Other Instructions */
diff --git a/sway-parse/src/item/item_impl.rs b/sway-parse/src/item/item_impl.rs
index 3894045f264..7dc51e86fce 100644
--- a/sway-parse/src/item/item_impl.rs
+++ b/sway-parse/src/item/item_impl.rs
@@ -88,12 +88,28 @@ mod tests {
 
     #[test]
     fn parse_impl_slice() {
-        let item = parse::<ItemImpl>(
-            r#"
-            impl __slice[T] {}
-            "#,
+        // deprecated syntax
+        let item = parse::<ItemImpl>("impl __slice[T] {}");
+        assert_matches!(
+            item.ty,
+            Ty::Slice {
+                slice_token: Some(..),
+                ty: _
+            }
         );
-        assert_matches!(item.ty, Ty::Slice { .. });
+
+        // "new" syntax
+        let item = parse::<ItemImpl>("impl [T] {}");
+        assert_matches!(
+            item.ty,
+            Ty::Slice {
+                slice_token: None,
+                ty: _
+            }
+        );
+
+        let item = parse::<ItemImpl>("impl &[T] {}");
+        assert_matches!(item.ty, Ty::Ref { ty, .. } if matches!(&*ty, Ty::Slice { .. }));
     }
 
     #[test]
diff --git a/sway-parse/src/module.rs b/sway-parse/src/module.rs
index edd33c8bb9c..7936012e96a 100644
--- a/sway-parse/src/module.rs
+++ b/sway-parse/src/module.rs
@@ -60,9 +60,7 @@ impl ParseToEnd for Annotated<Module> {
             }
         }
         let (kind, semicolon_token) = parser.parse()?;
-
         let (items, consumed) = parser.parse_to_end()?;
-
         let module = Annotated {
             attribute_list,
             value: Module {
diff --git a/sway-parse/src/parser.rs b/sway-parse/src/parser.rs
index ad9d3e7ffc2..804ead365b3 100644
--- a/sway-parse/src/parser.rs
+++ b/sway-parse/src/parser.rs
@@ -207,6 +207,18 @@ impl<'a, 'e> Parser<'a, 'e> {
         r
     }
 
+    /// This method is useful if `T` does not impl `ParseToEnd`
+    pub fn try_parse_and_check_empty<T: Parse>(
+        mut self,
+        append_diagnostics: bool,
+    ) -> ParseResult<Option<(T, ParserConsumed<'a>)>> {
+        let value = self.try_parse(append_diagnostics)?;
+        match self.check_empty() {
+            Some(consumed) => Ok(Some((value, consumed))),
+            None => Ok(None),
+        }
+    }
+
     /// Parses a `T` in its canonical way.
     pub fn parse<T: Parse>(&mut self) -> ParseResult<T> {
         T::parse(self)
@@ -223,13 +235,23 @@ impl<'a, 'e> Parser<'a, 'e> {
         T::parse_to_end(self)
     }
 
-    pub fn try_parse_to_end<T: Parse>(mut self) -> ParseResult<Option<(T, ParserConsumed<'a>)>> {
-        let value = self.parse()?;
-        let consumed = match self.check_empty() {
-            Some(consumed) => consumed,
-            None => return Ok(None),
+    /// Do not advance the parser on failure
+    pub fn try_parse_to_end<T: ParseToEnd>(
+        &mut self,
+        append_diagnostics: bool,
+    ) -> ParseResult<(T, ParserConsumed<'a>)> {
+        let handler = Handler::default();
+        let fork = Parser {
+            token_trees: self.token_trees,
+            full_span: self.full_span.clone(),
+            handler: &handler,
+            check_double_underscore: self.check_double_underscore,
         };
-        Ok(Some((value, consumed)))
+        let r = T::parse_to_end(fork);
+        if append_diagnostics {
+            self.handler.append(handler);
+        }
+        r
     }
 
     pub fn enter_delimited(
diff --git a/sway-parse/src/test_utils.rs b/sway-parse/src/test_utils.rs
index b0ceef2cbe4..976d2a4a958 100644
--- a/sway-parse/src/test_utils.rs
+++ b/sway-parse/src/test_utils.rs
@@ -1,3 +1,5 @@
+use sway_error::handler::Handler;
+
 use crate::{priv_prelude::ParseToEnd, Parse, Parser};
 use std::sync::Arc;
 
@@ -5,11 +7,15 @@ pub fn parse<T>(input: &str) -> T
 where
     T: Parse,
 {
-    let handler = <_>::default();
+    let handler = Handler::default();
     let ts = crate::token::lex(&handler, &Arc::from(input), 0, input.len(), None).unwrap();
-    Parser::new(&handler, &ts)
-        .parse()
-        .unwrap_or_else(|_| panic!("Parse error: {:?}", handler.consume().0))
+    let r = Parser::new(&handler, &ts).parse();
+
+    if handler.has_errors() || handler.has_warnings() {
+        panic!("{:?}", handler.consume());
+    }
+
+    r.unwrap_or_else(|_| panic!("Parse error: {:?}", handler.consume().0))
 }
 
 pub fn parse_to_end<T>(input: &str) -> T
@@ -18,8 +24,11 @@ where
 {
     let handler = <_>::default();
     let ts = crate::token::lex(&handler, &Arc::from(input), 0, input.len(), None).unwrap();
-    Parser::new(&handler, &ts)
-        .parse_to_end()
-        .map(|(m, _)| m)
-        .unwrap_or_else(|_| panic!("Parse error: {:?}", handler.consume().0))
+    let r = Parser::new(&handler, &ts).parse_to_end().map(|(m, _)| m);
+
+    if handler.has_errors() || handler.has_warnings() {
+        panic!("{:?}", handler.consume());
+    }
+
+    r.unwrap_or_else(|_| panic!("Parse error: {:?}", handler.consume().0))
 }
diff --git a/sway-parse/src/ty/mod.rs b/sway-parse/src/ty/mod.rs
index dcba9b74ef1..b01153da595 100644
--- a/sway-parse/src/ty/mod.rs
+++ b/sway-parse/src/ty/mod.rs
@@ -1,7 +1,6 @@
 use crate::{Parse, ParseBracket, ParseResult, ParseToEnd, Parser, ParserConsumed};
-
 use sway_ast::brackets::{Parens, SquareBrackets};
-use sway_ast::keywords::{DoubleColonToken, OpenAngleBracketToken};
+use sway_ast::keywords::{DoubleColonToken, OpenAngleBracketToken, PtrToken, SliceToken};
 use sway_ast::ty::{Ty, TyArrayDescriptor, TyTupleDescriptor};
 use sway_error::parser_error::ParseErrorKind;
 use sway_types::{ast::Delimiter, Ident};
@@ -30,9 +29,24 @@ impl Parse for Ty {
             return Err(parser
                 .emit_error(ParseErrorKind::ExpectedCommaOrCloseParenInTupleOrParenExpression));
         }
-        if let Some(descriptor) = SquareBrackets::try_parse(parser)? {
-            return Ok(Ty::Array(descriptor));
-        };
+
+        if let Some((mut inner_parser, span)) = parser.enter_delimited(Delimiter::Bracket) {
+            // array like [type; len]
+            if let Ok((array, _)) = inner_parser.try_parse_to_end::<TyArrayDescriptor>(false) {
+                return Ok(Ty::Array(SquareBrackets { inner: array, span }));
+            }
+
+            // slice like [type]
+            if let Ok(Some((ty, _))) = inner_parser.try_parse_and_check_empty::<Ty>(false) {
+                return Ok(Ty::Slice {
+                    slice_token: None,
+                    ty: SquareBrackets {
+                        inner: Box::new(ty),
+                        span,
+                    },
+                });
+            }
+        }
 
         if let Some(str_token) = parser.take() {
             let length = SquareBrackets::try_parse_all_inner(parser, |mut parser| {
@@ -48,18 +62,26 @@ impl Parse for Ty {
         if let Some(underscore_token) = parser.take() {
             return Ok(Ty::Infer { underscore_token });
         }
-        if let Some(ptr_token) = parser.take() {
+
+        if let Some(ptr_token) = parser.take::<PtrToken>() {
             let ty = SquareBrackets::parse_all_inner(parser, |mut parser| {
                 parser.emit_error(ParseErrorKind::UnexpectedTokenAfterPtrType)
             })?;
             return Ok(Ty::Ptr { ptr_token, ty });
         }
-        if let Some(slice_token) = parser.take() {
-            let ty = SquareBrackets::parse_all_inner(parser, |mut parser| {
+
+        // slice like __slice[type]
+        // TODO: deprecate this syntax (see https://github.com/FuelLabs/sway/issues/5110)
+        if let Some(slice_token) = parser.take::<SliceToken>() {
+            let ty = SquareBrackets::<Box<Ty>>::parse_all_inner(parser, |mut parser| {
                 parser.emit_error(ParseErrorKind::UnexpectedTokenAfterSliceType)
             })?;
-            return Ok(Ty::Slice { slice_token, ty });
+            return Ok(Ty::Slice {
+                slice_token: Some(slice_token),
+                ty,
+            });
         }
+
         if let Some(ampersand_token) = parser.take() {
             let mut_token = parser.take();
             let ty = Box::new(parser.parse()?);
@@ -69,9 +91,11 @@ impl Parse for Ty {
                 ty,
             });
         }
+
         if let Some(bang_token) = parser.take() {
             return Ok(Ty::Never { bang_token });
         }
+
         if parser.peek::<OpenAngleBracketToken>().is_some()
             || parser.peek::<DoubleColonToken>().is_some()
             || parser.peek::<Ident>().is_some()
@@ -79,6 +103,7 @@ impl Parse for Ty {
             let path_type = parser.parse()?;
             return Ok(Ty::Path(path_type));
         }
+
         Err(parser.emit_error(ParseErrorKind::ExpectedType))
     }
 }
@@ -121,14 +146,24 @@ mod tests {
         assert_matches!(item, Ty::Ptr { .. });
     }
 
+    #[test]
+    fn parse_array() {
+        let item = parse::<Ty>("[T; 1]");
+        assert_matches!(item, Ty::Array { .. });
+    }
+
     #[test]
     fn parse_slice() {
-        let item = parse::<Ty>(
-            r#"
-            __slice[T]
-            "#,
-        );
+        // deprecated syntax
+        let item = parse::<Ty>("__slice[T]");
         assert_matches!(item, Ty::Slice { .. });
+
+        // " new"  syntax
+        let item = parse::<Ty>("[T]");
+        assert_matches!(item, Ty::Slice { .. });
+
+        let item = parse::<Ty>("&[T]");
+        assert_matches!(item, Ty::Ref { ty, .. } if matches!(&*ty, Ty::Slice { .. }));
     }
 
     #[test]
diff --git a/sway-types/Cargo.toml b/sway-types/Cargo.toml
index ac484e455ad..aad3c5e52ac 100644
--- a/sway-types/Cargo.toml
+++ b/sway-types/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-types"
-version = "0.60.0"
+version.workspace = true
 description = "Sway core types."
 authors.workspace = true
 edition.workspace = true
@@ -9,19 +9,19 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-bytecount = "0.6"
-fuel-asm = { workspace = true }
-fuel-crypto = { workspace = true }
-fuel-tx = { workspace = true }
-indexmap = "2.0.0"
-lazy_static = "1.4"
-num-bigint = "0.4.3"
-num-traits = "0.2.16"
-parking_lot = "0.12"
-rustc-hash = "1.1.0"
-serde = { version = "1.0", features = ["derive"] }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-thiserror = "1"
+bytecount.workspace = true
+fuel-asm.workspace = true
+fuel-crypto.workspace = true
+fuel-tx.workspace = true
+indexmap.workspace = true
+lazy_static.workspace = true
+num-bigint.workspace = true
+num-traits.workspace = true
+parking_lot.workspace = true
+rustc-hash.workspace = true
+serde = { workspace = true, features = ["derive"] }
+sway-utils.workspace = true
+thiserror.workspace = true
 
 [features]
 no-span-debug = []
diff --git a/sway-types/src/constants.rs b/sway-types/src/constants.rs
index 5cbbabe1d97..7d1cc136cef 100644
--- a/sway-types/src/constants.rs
+++ b/sway-types/src/constants.rs
@@ -53,8 +53,6 @@ pub const CFG_EXPERIMENTAL_NEW_ENCODING: &str = "experimental_new_encoding";
 
 pub const DEPRECATED_ATTRIBUTE_NAME: &str = "deprecated";
 
-pub const NAMESPACE_ATTRIBUTE_NAME: &str = "namespace";
-
 pub const FALLBACK_ATTRIBUTE_NAME: &str = "fallback";
 
 /// The list of valid attributes.
diff --git a/sway-types/src/ident.rs b/sway-types/src/ident.rs
index 3f1dd1fe575..f4aa577bc5d 100644
--- a/sway-types/src/ident.rs
+++ b/sway-types/src/ident.rs
@@ -180,18 +180,22 @@ impl From<&IdentUnique> for Ident {
 impl Hash for IdentUnique {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.0.span().hash(state);
+        self.0.as_str().hash(state);
     }
 }
 
 impl PartialEq for IdentUnique {
     fn eq(&self, other: &Self) -> bool {
-        self.0.span() == other.0.span()
+        self.0.as_str() == other.0.as_str() && self.0.span() == other.0.span()
     }
 }
 
 impl Ord for IdentUnique {
     fn cmp(&self, other: &Self) -> Ordering {
-        self.0.span().cmp(&other.0.span())
+        self.0
+            .span()
+            .cmp(&other.0.span())
+            .then(self.0.as_str().cmp(other.0.as_str()))
     }
 }
 
diff --git a/sway-types/src/integer_bits.rs b/sway-types/src/integer_bits.rs
index d60be9f1bd5..d56df788022 100644
--- a/sway-types/src/integer_bits.rs
+++ b/sway-types/src/integer_bits.rs
@@ -9,6 +9,42 @@ pub enum IntegerBits {
     V256,
 }
 
+impl IntegerBits {
+    /// Returns if `v` would overflow using `self` bits or not.
+    pub fn would_overflow(&self, v: u64) -> bool {
+        if v == 0 {
+            return false;
+        }
+
+        let needed_bits = v.ilog2() + 1;
+        let bits = match self {
+            IntegerBits::Eight => 8,
+            IntegerBits::Sixteen => 16,
+            IntegerBits::ThirtyTwo => 32,
+            IntegerBits::SixtyFour => 64,
+            IntegerBits::V256 => return false,
+        };
+
+        needed_bits > bits
+    }
+}
+
+#[test]
+fn would_overflow_tests() {
+    assert!(!IntegerBits::Eight.would_overflow(0));
+
+    assert!(!IntegerBits::Eight.would_overflow(0xFF));
+    assert!(IntegerBits::Eight.would_overflow(0x100));
+
+    assert!(!IntegerBits::Sixteen.would_overflow(0xFFFF));
+    assert!(IntegerBits::Sixteen.would_overflow(0x10000));
+
+    assert!(!IntegerBits::ThirtyTwo.would_overflow(0xFFFFFFFF));
+    assert!(IntegerBits::ThirtyTwo.would_overflow(0x100000000));
+
+    assert!(!IntegerBits::SixtyFour.would_overflow(0xFFFFFFFFFFFFFFFF));
+}
+
 impl fmt::Display for IntegerBits {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use IntegerBits::{Eight, Sixteen, SixtyFour, ThirtyTwo, V256};
diff --git a/sway-utils/Cargo.toml b/sway-utils/Cargo.toml
index 81e02125986..1a379a23d51 100644
--- a/sway-utils/Cargo.toml
+++ b/sway-utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sway-utils"
-version = "0.60.0"
+version.workspace = true
 description = "Sway common utils."
 authors.workspace = true
 edition.workspace = true
@@ -9,8 +9,8 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-serde = { version = "1.0", features = ["derive"] }
-walkdir = "2.3.3"
+serde = { workspace = true, features = ["derive"] }
+walkdir.workspace = true
 
 [lints.clippy]
 iter_over_hash_type = "deny"
diff --git a/sway-utils/src/helpers.rs b/sway-utils/src/helpers.rs
index be67108ea35..45ca8603f0e 100644
--- a/sway-utils/src/helpers.rs
+++ b/sway-utils/src/helpers.rs
@@ -4,14 +4,15 @@ use std::{
     fs,
     path::{Path, PathBuf},
 };
+use walkdir::WalkDir;
 
 pub fn get_sway_files(path: PathBuf) -> Vec<PathBuf> {
     let mut files = vec![];
     let mut dir_entries = vec![path];
 
     while let Some(next_dir) = dir_entries.pop() {
-        if let Ok(read_dir) = fs::read_dir(next_dir) {
-            for entry in read_dir.filter_map(std::result::Result::ok) {
+        if let Ok(read_dir) = fs::read_dir(&next_dir) {
+            for entry in read_dir.filter_map(Result::ok) {
                 let path = entry.path();
                 if path.is_dir() {
                     dir_entries.push(path);
@@ -25,11 +26,10 @@ pub fn get_sway_files(path: PathBuf) -> Vec<PathBuf> {
 }
 
 pub fn is_sway_file(file: &Path) -> bool {
-    let res = file.extension();
-    file.is_file() && Some(OsStr::new(constants::SWAY_EXTENSION)) == res
+    file.is_file() && file.extension() == Some(OsStr::new(constants::SWAY_EXTENSION))
 }
 
-/// create an iterator over all prefixes in a slice, smallest first
+/// Create an iterator over all prefixes in a slice, smallest first
 ///
 /// ```
 /// # use sway_utils::iter_prefixes;
@@ -39,7 +39,6 @@ pub fn is_sway_file(file: &Path) -> bool {
 /// assert_eq!(it.next(), Some([1, 2].as_slice()));
 /// assert_eq!(it.next(), Some([1, 2, 3].as_slice()));
 /// assert_eq!(it.next(), None);
-///
 /// ```
 pub fn iter_prefixes<T>(slice: &[T]) -> impl DoubleEndedIterator<Item = &[T]> {
     (1..=slice.len()).map(move |len| &slice[..len])
@@ -54,7 +53,6 @@ pub fn find_nested_manifest_dir(starter_path: &Path) -> Option<PathBuf> {
 ///
 /// Starts the search from child dirs of `starter_path`.
 pub fn find_nested_dir_with_file(starter_path: &Path, file_name: &str) -> Option<PathBuf> {
-    use walkdir::WalkDir;
     let starter_dir = if starter_path.is_dir() {
         starter_path
     } else {
@@ -62,8 +60,7 @@ pub fn find_nested_dir_with_file(starter_path: &Path, file_name: &str) -> Option
     };
     WalkDir::new(starter_path).into_iter().find_map(|e| {
         let entry = e.ok()?;
-        if entry.path() != starter_dir.join(file_name)
-            && entry.file_name().to_string_lossy() == file_name
+        if entry.path() != starter_dir.join(file_name) && entry.file_name() == OsStr::new(file_name)
         {
             let mut entry = entry.path().to_path_buf();
             entry.pop();
@@ -77,14 +74,13 @@ pub fn find_nested_dir_with_file(starter_path: &Path, file_name: &str) -> Option
 /// Continually go up in the file tree until a specified file is found.
 ///
 /// Starts the search from `starter_path`.
-#[allow(clippy::branches_sharing_code)]
 pub fn find_parent_dir_with_file<P: AsRef<Path>>(
     starter_path: P,
     file_name: &str,
 ) -> Option<PathBuf> {
     let mut path = std::fs::canonicalize(starter_path).ok()?;
-    let empty_path = PathBuf::from("/");
-    while path != empty_path {
+    let root_path = PathBuf::from("/");
+    while path != root_path {
         path.push(file_name);
         if path.exists() {
             path.pop();
@@ -95,28 +91,29 @@ pub fn find_parent_dir_with_file<P: AsRef<Path>>(
     }
     None
 }
+
 /// Continually go up in the file tree until a Forc manifest file is found.
 pub fn find_parent_manifest_dir<P: AsRef<Path>>(starter_path: P) -> Option<PathBuf> {
     find_parent_dir_with_file(starter_path, constants::MANIFEST_FILE_NAME)
 }
 
-/// Continually go up in the file tree until a Forc manifest file is found and given predicate
+/// Continually go up in the file tree until a Forc manifest file is found and the given predicate
 /// returns true.
 pub fn find_parent_manifest_dir_with_check<T: AsRef<Path>, F>(
     starter_path: T,
-    f: F,
+    check: F,
 ) -> Option<PathBuf>
 where
     F: Fn(&Path) -> bool,
 {
-    find_parent_manifest_dir(starter_path).and_then(|manifest_dir| {
-        // If given check satisfies return current dir otherwise start searching from the parent.
-        if f(&manifest_dir) {
+    find_parent_manifest_dir(&starter_path).and_then(|manifest_dir| {
+        // If given check satisfies, return the current dir; otherwise, start searching from the parent.
+        if check(&manifest_dir) {
             Some(manifest_dir)
-        } else if let Some(parent_dir) = manifest_dir.parent() {
-            find_parent_manifest_dir_with_check(parent_dir, f)
         } else {
-            None
+            manifest_dir
+                .parent()
+                .and_then(|parent_dir| find_parent_manifest_dir_with_check(parent_dir, check))
         }
     })
 }
diff --git a/swayfmt/Cargo.toml b/swayfmt/Cargo.toml
index 97c8d19fda7..584bc0320ec 100644
--- a/swayfmt/Cargo.toml
+++ b/swayfmt/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "swayfmt"
-version = "0.60.0"
+version.workspace = true
 description = "Sway language formatter."
 authors.workspace = true
 edition.workspace = true
@@ -9,19 +9,20 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-anyhow = "1"
-forc-tracing = { version = "0.60.0", path = "../forc-tracing" }
-ropey = "1.5"
-serde = { version = "1.0", features = ["derive"] }
-serde_ignored = "0.1.9"
-sway-ast = { version = "0.60.0", path = "../sway-ast" }
-sway-core = { version = "0.60.0", path = "../sway-core" }
-sway-error = { version = "0.60.0", path = "../sway-error" }
-sway-parse = { version = "0.60.0", path = "../sway-parse" }
-sway-types = { version = "0.60.0", path = "../sway-types" }
-sway-utils = { version = "0.60.0", path = "../sway-utils" }
-thiserror = "1.0.30"
-toml = { version = "0.7", features = ["parse"] }
+anyhow.workspace = true
+forc-tracing.workspace = true
+indoc.workspace = true
+ropey.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_ignored.workspace = true
+sway-ast.workspace = true
+sway-core.workspace = true
+sway-error.workspace = true
+sway-parse.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+thiserror.workspace = true
+toml = { workspace = true, features = ["parse"] }
 
 [dev-dependencies]
 difference = "2.0.0"
diff --git a/swayfmt/README.md b/swayfmt/README.md
index db43730266a..42fc5c79741 100644
--- a/swayfmt/README.md
+++ b/swayfmt/README.md
@@ -6,54 +6,3 @@ A tool for formatting Sway code according to style guidelines.
 
 - To use `swayfmt`, install the [forc-fmt](../forc-plugins/forc-fmt/) plugin using [fuelup](https://github.com/FuelLabs/fuelup).
 - To contribute to `swayfmt`, see [CONTRIBUTING](./CONTRIBUTING.md).
-
-## Configuration with `swayfmt.toml`
-
-Swayfmt _is_ meant to be configurable, however currently it only supports the default configuration options.
-
-> **Note:** Not all `Config` options are guaranteed to work
-> and most are not implemented. Configuration options are
-> subject to change between versions without notice.
-> If you would like to see a feature implemented, or
-> implement a feature please refer to the [CONTRIBUTING guide](./CONTRIBUTING.md).
-
-The default `swayfmt.toml`:
-
-```toml
-max_width = 100
-hard_tabs = false
-tab_spaces = 4
-newline_style = Auto
-indent_style = Block
-newline_threshold = 1
-group_imports = Preserve
-imports_granularity = Preserve
-imports_indent = Block
-reorder_imports = true
-reorder_modules = true
-reorder_impl_items = false
-item_brace_style = SameLineWhere
-blank_lines_upper_bound = 1
-blank_lines_lower_bound = 0
-empty_item_single_line = true
-format_strings = false
-hex_literal_case = Preserve
-expr_brace_style = AlwaysSameLine
-trailing_semicolon = true
-space_before_colon = false
-space_after_colon = false
-type_combinator_layout = Wide
-spaces_around_ranges = false
-match_block_trailing_comma = false
-match_arm_leading_pipe = Never
-force_multiline_blocks = false
-fn_args_layout = Tall
-fn_single_line = false
-heuristics_pref = Scaled
-use_small_heuristics = true
-field_alignment = Off
-small_structures_single_line = true
-wrap_comments = false
-comment_width = 80
-normalize_comments = false
-```
diff --git a/swayfmt/src/config/heuristics.rs b/swayfmt/src/config/heuristics.rs
index 123c8d44566..83dd4067c4a 100644
--- a/swayfmt/src/config/heuristics.rs
+++ b/swayfmt/src/config/heuristics.rs
@@ -93,12 +93,12 @@ impl WidthHeuristics {
     /// Using this WidthHeuristics means we ignore heuristics.
     pub fn off() -> WidthHeuristics {
         WidthHeuristics {
-            fn_call_width: usize::max_value(),
-            attr_fn_like_width: usize::max_value(),
+            fn_call_width: usize::MAX,
+            attr_fn_like_width: usize::MAX,
             structure_lit_width: 0,
             structure_field_width: 0,
-            collection_width: usize::max_value(),
-            chain_width: usize::max_value(),
+            collection_width: usize::MAX,
+            chain_width: usize::MAX,
             single_line_if_else_max_width: 0,
             short_array_element_width: 0,
         }
diff --git a/swayfmt/src/items/item_storage/mod.rs b/swayfmt/src/items/item_storage/mod.rs
index 0fa131b55bc..c6fa0fdf189 100644
--- a/swayfmt/src/items/item_storage/mod.rs
+++ b/swayfmt/src/items/item_storage/mod.rs
@@ -275,6 +275,12 @@ impl LeafSpans for StorageEntry {
 impl LeafSpans for StorageField {
     fn leaf_spans(&self) -> Vec<ByteSpan> {
         let mut collected_spans = vec![ByteSpan::from(self.name.span())];
+        if let Some(in_token) = &self.in_token {
+            collected_spans.push(ByteSpan::from(in_token.span()));
+        }
+        if let Some(key_expr) = &self.key_expr {
+            collected_spans.push(ByteSpan::from(key_expr.span()));
+        }
         collected_spans.push(ByteSpan::from(self.colon_token.span()));
         collected_spans.append(&mut self.ty.leaf_spans());
         collected_spans.push(ByteSpan::from(self.eq_token.span()));
diff --git a/swayfmt/src/utils/language/punctuated.rs b/swayfmt/src/utils/language/punctuated.rs
index 852d4224efc..a06a6c68e55 100644
--- a/swayfmt/src/utils/language/punctuated.rs
+++ b/swayfmt/src/utils/language/punctuated.rs
@@ -258,12 +258,15 @@ impl Format for StorageField {
         formatter.with_shape(
             formatter.shape.with_default_code_line(),
             |formatter| -> Result<(), FormatterError> {
-                write!(
-                    formatted_code,
-                    "{}{} ",
-                    self.name.span().as_str(),
-                    self.colon_token.span().as_str(),
-                )?;
+                write!(formatted_code, "{}", self.name.span().as_str())?;
+                if let Some(in_token) = &self.in_token {
+                    write!(formatted_code, " {}", in_token.span().as_str())?;
+                }
+                if let Some(key_expr) = &self.key_expr {
+                    write!(formatted_code, " {}", key_expr.span().as_str())?;
+                }
+                write!(formatted_code, "{} ", self.colon_token.span().as_str())?;
+
                 self.ty.format(formatted_code, formatter)?;
                 write!(formatted_code, " {} ", self.eq_token.span().as_str())?;
 
@@ -272,7 +275,6 @@ impl Format for StorageField {
         )?;
 
         self.initializer.format(formatted_code, formatter)?;
-
         Ok(())
     }
 }
diff --git a/swayfmt/src/utils/language/ty.rs b/swayfmt/src/utils/language/ty.rs
index 1d764e83bd7..a509cca1567 100644
--- a/swayfmt/src/utils/language/ty.rs
+++ b/swayfmt/src/utils/language/ty.rs
@@ -117,15 +117,20 @@ fn format_ptr(
 
 fn format_slice(
     formatted_code: &mut FormattedCode,
-    slice_token: SliceToken,
+    slice_token: Option<SliceToken>,
     ty: SquareBrackets<Box<Ty>>,
 ) -> Result<(), FormatterError> {
-    write!(
-        formatted_code,
-        "{}[{}]",
-        slice_token.span().as_str(),
-        ty.into_inner().span().as_str()
-    )?;
+    if let Some(slice_token) = slice_token {
+        write!(
+            formatted_code,
+            "{}[{}]",
+            slice_token.span().as_str(),
+            ty.into_inner().span().as_str()
+        )?;
+    } else {
+        write!(formatted_code, "[{}]", ty.into_inner().span().as_str())?;
+    }
+
     Ok(())
 }
 
@@ -202,7 +207,11 @@ impl LeafSpans for Ty {
                 collected_spans
             }
             Ty::Slice { slice_token, ty } => {
-                let mut collected_spans = vec![ByteSpan::from(slice_token.span())];
+                let mut collected_spans = if let Some(slice_token) = slice_token {
+                    vec![ByteSpan::from(slice_token.span())]
+                } else {
+                    vec![]
+                };
                 collected_spans.append(&mut ty.leaf_spans());
                 collected_spans
             }
diff --git a/swayfmt/src/utils/map/newline.rs b/swayfmt/src/utils/map/newline.rs
index e78d1aa8f67..769b05e7ad3 100644
--- a/swayfmt/src/utils/map/newline.rs
+++ b/swayfmt/src/utils/map/newline.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use ropey::{str_utils::byte_to_char_idx, Rope};
-use std::{collections::BTreeMap, path::PathBuf, sync::Arc};
+use std::{collections::BTreeMap, fmt::Display, path::PathBuf, sync::Arc};
 use sway_ast::Module;
 use sway_types::SourceEngine;
 
@@ -18,11 +18,15 @@ struct NewlineSequence {
     sequence_length: usize,
 }
 
-impl ToString for NewlineSequence {
-    fn to_string(&self) -> String {
-        (0..self.sequence_length - 1)
-            .map(|_| NEW_LINE)
-            .collect::<String>()
+impl Display for NewlineSequence {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            (0..self.sequence_length - 1)
+                .map(|_| NEW_LINE)
+                .collect::<String>()
+        )
     }
 }
 
diff --git a/swayfmt/tests/mod.rs b/swayfmt/tests/mod.rs
index 9676b68d20a..890995ef338 100644
--- a/swayfmt/tests/mod.rs
+++ b/swayfmt/tests/mod.rs
@@ -1,3 +1,4 @@
+use indoc::indoc;
 use std::sync::Arc;
 use swayfmt::{config::user_def::FieldAlignment, Formatter};
 use test_macros::assert_eq_pretty;
@@ -23,38 +24,43 @@ fn check(unformatted: &str, expected: &str) {
 #[test]
 fn module_doc_comments_persist() {
     check(
-        r#"
+        indoc! {r#"
 
-//! this is a module level doc comment
-library;
-        "#,
-        r#"//! this is a module level doc comment
-library;
-"#,
+        //! this is a module level doc comment
+        library;
+        "#},
+        indoc! {r#"
+        //! this is a module level doc comment
+        library;
+        "#},
     )
 }
 
 #[test]
 fn conserve_pub_mod() {
     check(
-        r#"contract;
-pub mod foo;
-"#,
-        r#"contract;
-pub mod foo;
-"#,
+        indoc! {r#"
+        contract;
+        pub mod foo;
+        "#},
+        indoc! {r#"
+        contract;
+        pub mod foo;
+        "#},
     )
 }
 
 #[test]
 fn const_spacing() {
     check(
-        r#"contract;
-pub const TEST:u16=10;
-"#,
-        r#"contract;
-pub const TEST: u16 = 10;
-"#,
+        indoc! {r#"
+        contract;
+        pub const TEST:u16=10;
+        "#},
+        indoc! {r#"
+        contract;
+        pub const TEST: u16 = 10;
+        "#},
     )
 }
 
@@ -64,18 +70,20 @@ fn struct_alignment() {
     formatter.config.structures.field_alignment = FieldAlignment::AlignFields(40);
 
     check_with_formatter(
-        r#"contract;
-pub struct Foo<T, P> {
-   barbazfoo: u64,
-   baz  : bool,
-}
-"#,
-        r#"contract;
-pub struct Foo<T, P> {
-    barbazfoo : u64,
-    baz       : bool,
-}
-"#,
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+           barbazfoo: u64,
+           baz  : bool,
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+            barbazfoo : u64,
+            baz       : bool,
+        }
+        "#},
         &mut formatter,
     );
 }
@@ -86,34 +94,38 @@ fn struct_alignment_with_public_fields() {
     formatter.config.structures.field_alignment = FieldAlignment::AlignFields(40);
 
     check_with_formatter(
-        r#"contract;
-pub struct Foo<T, P> {
-   barbazfoo: u64,
-   pub baz     : bool,
-}
-"#,
-        r#"contract;
-pub struct Foo<T, P> {
-    barbazfoo : u64,
-    pub baz   : bool,
-}
-"#,
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+           barbazfoo: u64,
+           pub baz     : bool,
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+            barbazfoo : u64,
+            pub baz   : bool,
+        }
+        "#},
         &mut formatter,
     );
 
     check_with_formatter(
-        r#"contract;
-pub struct Foo<T, P> {
-   pub barbazfoo: u64,
-   baz     : bool,
-}
-"#,
-        r#"contract;
-pub struct Foo<T, P> {
-    pub barbazfoo : u64,
-    baz           : bool,
-}
-"#,
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+           pub barbazfoo: u64,
+           baz     : bool,
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+            pub barbazfoo : u64,
+            baz           : bool,
+        }
+        "#},
         &mut formatter,
     );
 }
@@ -124,20 +136,22 @@ fn struct_public_fields() {
     formatter.config.structures.field_alignment = FieldAlignment::Off;
 
     check_with_formatter(
-        r#"contract;
-pub struct Foo<T, P> {
-   pub  barbaz:   T,
-   foo: u64,
-     pub  baz  : bool,
-}
-"#,
-        r#"contract;
-pub struct Foo<T, P> {
-    pub barbaz: T,
-    foo: u64,
-    pub baz: bool,
-}
-"#,
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+           pub  barbaz:   T,
+           foo: u64,
+             pub  baz  : bool,
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        pub struct Foo<T, P> {
+            pub barbaz: T,
+            foo: u64,
+            pub baz: bool,
+        }
+        "#},
         &mut formatter,
     );
 }
@@ -145,145 +159,179 @@ pub struct Foo<T, P> {
 #[test]
 fn struct_ending_comma() {
     check(
-        r#"contract;
-pub struct Foo {
-    bar: u64,
-    baz: bool
-}
-"#,
-        r#"contract;
-pub struct Foo {
-    bar: u64,
-    baz: bool,
-}
-"#,
+        indoc! {r#"
+        contract;
+        pub struct Foo {
+            bar: u64,
+            baz: bool
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        pub struct Foo {
+            bar: u64,
+            baz: bool,
+        }
+        "#},
     );
 }
 
 #[test]
 fn enum_without_variant_alignment() {
     check(
-        r#"contract;
-
-enum Color {
-    Blue: (), Green: (),
+        indoc! {r#"
+        contract;
+
+        enum Color {
+            Blue: (), Green: (),
+                    Red: (),
+            Silver: (),
+                            Grey: () }
+        "#},
+        indoc! {r#"
+        contract;
+
+        enum Color {
+            Blue: (),
+            Green: (),
             Red: (),
-    Silver: (),
-                    Grey: () }
-        "#,
-        r#"contract;
-
-enum Color {
-    Blue: (),
-    Green: (),
-    Red: (),
-    Silver: (),
-    Grey: (),
-}
-"#,
+            Silver: (),
+            Grey: (),
+        }
+        "#},
     );
 }
+
 #[test]
 fn enum_with_variant_alignment() {
     // Creating a config with enum_variant_align_threshold that exceeds longest variant length
     let mut formatter = Formatter::default();
     formatter.config.structures.field_alignment = FieldAlignment::AlignFields(20);
     check_with_formatter(
-        r#"contract;
-
-enum Color {
-    Blue: (), Green: (),
-            Red: (),
-    Silver: (),
-                    Grey: (), }
-        "#,
-        r#"contract;
-
-enum Color {
-    Blue   : (),
-    Green  : (),
-    Red    : (),
-    Silver : (),
-    Grey   : (),
-}
-"#,
+        indoc! {r#"
+        contract;
+
+        enum Color {
+            Blue: (), Green: (),
+                    Red: (),
+            Silver: (),
+                            Grey: (), }
+        "#},
+        indoc! {r#"
+        contract;
+
+        enum Color {
+            Blue   : (),
+            Green  : (),
+            Red    : (),
+            Silver : (),
+            Grey   : (),
+        }
+        "#},
         &mut formatter,
     );
 }
+
 #[test]
 fn item_abi_with_generics_and_attributes() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-abi StorageMapExample {
-    #[storage(write)]fn insert_into_map1(key: u64, value: u64);
+        abi StorageMapExample {
+            #[storage(write)]fn insert_into_map1(key: u64, value: u64);
 
-fn hello(key: u64, value: u64);
-}"#,
-        r#"contract;
+        fn hello(key: u64, value: u64);
+        }"#},
+        indoc! {r#"
+        contract;
 
-abi StorageMapExample {
-    #[storage(write)]
-    fn insert_into_map1(key: u64, value: u64);
+        abi StorageMapExample {
+            #[storage(write)]
+            fn insert_into_map1(key: u64, value: u64);
 
-    fn hello(key: u64, value: u64);
-}
-"#,
+            fn hello(key: u64, value: u64);
+        }
+        "#},
     );
 }
 
 #[test]
 fn multi_items() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-pub const TEST: u16 = 10;
-pub const TEST1: u16 = 10;"#,
-        r#"contract;
+        pub const TEST: u16 = 10;
+        pub const TEST1: u16 = 10;"#},
+        indoc! {r#"
+        contract;
 
-pub const TEST: u16 = 10;
-pub const TEST1: u16 = 10;
-"#,
+        pub const TEST: u16 = 10;
+        pub const TEST1: u16 = 10;
+        "#},
     );
 }
+
 #[test]
 fn ty_formatting() {
     check(
-        r#"contract;
-
-enum TestTy {
-    Infer:
-    _,
-    Array : [u8;
-    40],
-    String:         str[
-    4
-    ],
-    PathType     : root::
-example::
-    some_type,
-    TupleNil: (),
-    Tuple: (   u64,
-        u32
-    ),
-}"#,
-        r#"contract;
-
-enum TestTy {
-    Infer: _,
-    Array: [u8; 40],
-    String: str[4],
-    PathType: root::example::some_type,
-    TupleNil: (),
-    Tuple: (u64, u32),
-}
-"#,
+        indoc! {r#"
+        contract;
+
+        enum TestTy {
+            Infer:
+            _,
+            Array : [u8;
+            40],
+            String:         str[
+            4
+            ],
+            PathType     : root::
+        example::
+            some_type,
+            TupleNil: (),
+            Tuple: (   u64,
+                u32
+            ),
+        }"#},
+        indoc! {r#"
+        contract;
+
+        enum TestTy {
+            Infer: _,
+            Array: [u8; 40],
+            String: str[4],
+            PathType: root::example::some_type,
+            TupleNil: (),
+            Tuple: (u64, u32),
+        }
+        "#},
     );
 }
+
 #[test]
 fn storage_without_alignment() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
+
+                struct Type1 {
+                    foo: u64,
+                }
+
+                struct Type2 {
+                    bar: u64,
+                }
+
+                storage {
+                 var1: Type1=Type1{ foo: 8 },
+                      var2: Type2=Type2{ bar: 9 },
+                      ns1 { var3: u64 = 1, ns2 { var4: u64 = 1 } },
+                }
+        "#},
+        indoc! {r#"
+        contract;
 
         struct Type1 {
             foo: u64,
@@ -294,292 +342,294 @@ fn storage_without_alignment() {
         }
 
         storage {
-         var1: Type1=Type1{ foo: 8 },
-              var2: Type2=Type2{ bar: 9 },
-              ns1 { var3: u64 = 1, ns2 { var4: u64 = 1 } },
+            var1: Type1 = Type1 { foo: 8 },
+            var2: Type2 = Type2 { bar: 9 },
+            ns1 {
+                var3: u64 = 1,
+                ns2 {
+                    var4: u64 = 1,
+                },
+            },
         }
-        "#,
-        r#"contract;
-
-struct Type1 {
-    foo: u64,
-}
-
-struct Type2 {
-    bar: u64,
-}
-
-storage {
-    var1: Type1 = Type1 { foo: 8 },
-    var2: Type2 = Type2 { bar: 9 },
-    ns1 {
-        var3: u64 = 1,
-        ns2 {
-            var4: u64 = 1,
-        },
-    },
-}
-"#,
+        "#},
     );
 }
+
 #[test]
 fn storage_with_alignment() {
     let mut formatter = Formatter::default();
     formatter.config.structures.field_alignment = FieldAlignment::AlignFields(50);
     check_with_formatter(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-struct Type1 {
-    foo: u64,
-}
+        struct Type1 {
+            foo: u64,
+        }
 
-struct Type2 {
-    bar: u64,
-}
+        struct Type2 {
+            bar: u64,
+        }
 
-storage {
- long_var_name: Type1=Type1{ foo: 8 },
-      var2: Type2=Type2{ bar: 9 },
-      ns1 { var3: u64 = 1,  ns2 { var4: u64 = 1, },  }, var5: u64 = 1
-}
-"#,
-        r#"contract;
+        storage {
+         long_var_name: Type1=Type1{ foo: 8 },
+              var2: Type2=Type2{ bar: 9 },
+              ns1 { var3: u64 = 1,  ns2 { var4: u64 = 1, },  }, var5: u64 = 1
+        }
+        "#},
+        indoc! {r#"
+        contract;
 
-struct Type1 {
-    foo : u64,
-}
+        struct Type1 {
+            foo : u64,
+        }
 
-struct Type2 {
-    bar : u64,
-}
+        struct Type2 {
+            bar : u64,
+        }
 
-storage {
-    long_var_name : Type1 = Type1 { foo: 8 },
-    var2          : Type2 = Type2 { bar: 9 },
-    ns1 {
-        var3      : u64 = 1,
-        ns2 {
-            var4  : u64 = 1,
-        },
-    },
-    var5          : u64 = 1
-}
-"#,
+        storage {
+            long_var_name : Type1 = Type1 { foo: 8 },
+            var2          : Type2 = Type2 { bar: 9 },
+            ns1 {
+                var3      : u64 = 1,
+                ns2 {
+                    var4  : u64 = 1,
+                },
+            },
+            var5          : u64 = 1
+        }
+        "#},
         &mut formatter,
     );
 }
+
 #[test]
 fn storage_initializer() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-struct Type1 {
-    x: u64,
-    y: u64,
-}
+        struct Type1 {
+            x: u64,
+            y: u64,
+        }
 
-struct Type2 {
-    w: b256,
-    z: bool,
-}
+        struct Type2 {
+            w: b256,
+            z: bool,
+        }
 
-storage {
-    var1: Type1 = Type1 {
+        storage {
+            var1: Type1 = Type1 {
 
-        x: 0,
+                x: 0,
 
-        y:
-        0,
-        },
-    var2: Type2 = Type2 { w: 0x0000000000000000000000000000000000000000000000000000000000000000,z: false,
-    },
-}"#,
-        r#"contract;
+                y:
+                0,
+                },
+            var2: Type2 = Type2 { w: 0x0000000000000000000000000000000000000000000000000000000000000000,z: false,
+            },
+        }"#},
+        indoc! {r#"
+        contract;
 
-struct Type1 {
-    x: u64,
-    y: u64,
-}
+        struct Type1 {
+            x: u64,
+            y: u64,
+        }
 
-struct Type2 {
-    w: b256,
-    z: bool,
-}
+        struct Type2 {
+            w: b256,
+            z: bool,
+        }
 
-storage {
-    var1: Type1 = Type1 { x: 0, y: 0 },
-    var2: Type2 = Type2 {
-        w: 0x0000000000000000000000000000000000000000000000000000000000000000,
-        z: false,
-    },
-}
-"#,
+        storage {
+            var1: Type1 = Type1 { x: 0, y: 0 },
+            var2: Type2 = Type2 {
+                w: 0x0000000000000000000000000000000000000000000000000000000000000000,
+                z: false,
+            },
+        }
+        "#},
     );
 }
+
 #[test]
 fn item_fn() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-pub fn hello( person: String ) -> String {let greeting = 42;greeting.to_string()}
-fn goodbye() -> usize {let farewell: usize = 5; farewell }"#,
-        r#"contract;
+        pub fn hello( person: String ) -> String {let greeting = 42;greeting.to_string()}
+        fn goodbye() -> usize {let farewell: usize = 5; farewell }"#},
+        indoc! {r#"
+        contract;
 
-pub fn hello(person: String) -> String {
-    let greeting = 42;
-    greeting.to_string()
-}
-fn goodbye() -> usize {
-    let farewell: usize = 5;
-    farewell
-}
-"#,
+        pub fn hello(person: String) -> String {
+            let greeting = 42;
+            greeting.to_string()
+        }
+        fn goodbye() -> usize {
+            let farewell: usize = 5;
+            farewell
+        }
+        "#},
     );
 }
+
 #[test]
 fn same_line_where() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-pub fn hello( person: String ) -> String where T: Eq,{let greeting = 42;greeting.to_string()}"#,
-        r#"contract;
+        pub fn hello( person: String ) -> String where T: Eq,{let greeting = 42;greeting.to_string()}"#},
+        indoc! {r#"
+        contract;
 
-pub fn hello(person: String) -> String
-where
-    T: Eq,
-{
-    let greeting = 42;
-    greeting.to_string()
-}
-"#,
+        pub fn hello(person: String) -> String
+        where
+            T: Eq,
+        {
+            let greeting = 42;
+            greeting.to_string()
+        }
+        "#},
     );
 }
+
 #[test]
 fn trait_and_super_trait() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-trait Person{ fn name( self )->String;fn age( self )->usize; }
-trait Student:Person {fn university(self) -> String;}
-trait Programmer {fn fav_language(self) -> String;}
-trait CompSciStudent: Programmer+Student {fn git_username(self) -> String;}
-trait TraitWithGenerics<T> where T: String {fn from(b: T) -> Self;}"#,
-        r#"library;
+        trait Person{ fn name( self )->String;fn age( self )->usize; }
+        trait Student:Person {fn university(self) -> String;}
+        trait Programmer {fn fav_language(self) -> String;}
+        trait CompSciStudent: Programmer+Student {fn git_username(self) -> String;}
+        trait TraitWithGenerics<T> where T: String {fn from(b: T) -> Self;}"#},
+        indoc! {r#"
+        library;
 
-trait Person {
-    fn name(self) -> String;
-    fn age(self) -> usize;
-}
-trait Student: Person {
-    fn university(self) -> String;
-}
-trait Programmer {
-    fn fav_language(self) -> String;
-}
-trait CompSciStudent: Programmer + Student {
-    fn git_username(self) -> String;
-}
-trait TraitWithGenerics<T>
-where
-    T: String,
-{
-    fn from(b: T) -> Self;
-}
-"#,
+        trait Person {
+            fn name(self) -> String;
+            fn age(self) -> usize;
+        }
+        trait Student: Person {
+            fn university(self) -> String;
+        }
+        trait Programmer {
+            fn fav_language(self) -> String;
+        }
+        trait CompSciStudent: Programmer + Student {
+            fn git_username(self) -> String;
+        }
+        trait TraitWithGenerics<T>
+        where
+            T: String,
+        {
+            fn from(b: T) -> Self;
+        }
+        "#},
     );
 }
+
 #[test]
 fn method_calls() {
     let mut formatter = Formatter::default();
     formatter.config.structures.small_structures_single_line = true;
     formatter.config.whitespace.max_width = 220;
     check_with_formatter(
-        r#"script;
-
-struct Opts {
-    gas: u64,
-    coins: u64,
-    id: ContractId,
-}
+        indoc! {r#"
+        script;
 
-fn  main(       ) -> bool{
-    let default_gas  = 1_000_000_000_000           ;let fuelcoin_id = ContractId::from(0x018f59fe434b323a5054e7bb41de983f4926a3c5d3e4e1f9f33b5f0f0e611889);
+        struct Opts {
+            gas: u64,
+            coins: u64,
+            id: ContractId,
+        }
 
-    let balance_test_id = ContractId :: from( 0x597e5ddb1a6bec92a96a73e4f0bc6f6e3e7b21f5e03e1c812cd63cffac480463 ) ;
+        fn  main(       ) -> bool{
+            let default_gas  = 1_000_000_000_000           ;let fuelcoin_id = ContractId::from(0x018f59fe434b323a5054e7bb41de983f4926a3c5d3e4e1f9f33b5f0f0e611889);
 
-    let fuel_coin = abi(    TestFuelCoin, fuelcoin_id.into(       ) ) ;
+            let balance_test_id = ContractId :: from( 0x597e5ddb1a6bec92a96a73e4f0bc6f6e3e7b21f5e03e1c812cd63cffac480463 ) ;
 
-    assert(fuelcoin_balance == 0);
+            let fuel_coin = abi(    TestFuelCoin, fuelcoin_id.into(       ) ) ;
 
-    fuel_coin.mint        {
-        gas:             default_gas
-    }
+            assert(fuelcoin_balance == 0);
 
-    (11);
+            fuel_coin.mint        {
+                gas:             default_gas
+            }
 
-    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
-    assert( fuelcoin_balance   == 11 ) ;
+            (11);
 
-    fuel_coin.burn {
-        gas: default_gas
-    }
-    (7);
+            fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
+            assert( fuelcoin_balance   == 11 ) ;
 
-    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
-    assert(fuelcoin_balance == 4);
+            fuel_coin.burn {
+                gas: default_gas
+            }
+            (7);
 
-    fuel_coin.force_transfer {
-        gas: default_gas
-    }
-    (3, fuelcoin_id, balance_test_id);
+            fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
+            assert(fuelcoin_balance == 4);
 
-    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
-    let balance_test_contract_balance = balance_of(fuelcoin_id, balance_test_id);
-    assert(fuelcoin_balance == 1);
-    assert(balance_test_contract_balance == 3);
+            fuel_coin.force_transfer {
+                gas: default_gas
+            }
+            (3, fuelcoin_id, balance_test_id);
 
-    true
-}"#,
-        r#"script;
+            fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
+            let balance_test_contract_balance = balance_of(fuelcoin_id, balance_test_id);
+            assert(fuelcoin_balance == 1);
+            assert(balance_test_contract_balance == 3);
 
-struct Opts {
-    gas: u64,
-    coins: u64,
-    id: ContractId,
-}
+            true
+        }"#},
+        indoc! {r#"
+        script;
+
+        struct Opts {
+            gas: u64,
+            coins: u64,
+            id: ContractId,
+        }
 
-fn main() -> bool {
-    let default_gas = 1_000_000_000_000;
-    let fuelcoin_id = ContractId::from(0x018f59fe434b323a5054e7bb41de983f4926a3c5d3e4e1f9f33b5f0f0e611889);
+        fn main() -> bool {
+            let default_gas = 1_000_000_000_000;
+            let fuelcoin_id = ContractId::from(0x018f59fe434b323a5054e7bb41de983f4926a3c5d3e4e1f9f33b5f0f0e611889);
 
-    let balance_test_id = ContractId::from(0x597e5ddb1a6bec92a96a73e4f0bc6f6e3e7b21f5e03e1c812cd63cffac480463);
+            let balance_test_id = ContractId::from(0x597e5ddb1a6bec92a96a73e4f0bc6f6e3e7b21f5e03e1c812cd63cffac480463);
 
-    let fuel_coin = abi(TestFuelCoin, fuelcoin_id.into());
+            let fuel_coin = abi(TestFuelCoin, fuelcoin_id.into());
 
-    assert(fuelcoin_balance == 0);
+            assert(fuelcoin_balance == 0);
 
-    fuel_coin.mint { gas: default_gas }(11);
+            fuel_coin.mint { gas: default_gas }(11);
 
-    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
-    assert(fuelcoin_balance == 11);
+            fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
+            assert(fuelcoin_balance == 11);
 
-    fuel_coin.burn { gas: default_gas }(7);
+            fuel_coin.burn { gas: default_gas }(7);
 
-    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
-    assert(fuelcoin_balance == 4);
+            fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
+            assert(fuelcoin_balance == 4);
 
-    fuel_coin.force_transfer {
-        gas: default_gas,
-    }(3, fuelcoin_id, balance_test_id);
+            fuel_coin.force_transfer {
+                gas: default_gas,
+            }(3, fuelcoin_id, balance_test_id);
 
-    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
-    let balance_test_contract_balance = balance_of(fuelcoin_id, balance_test_id);
-    assert(fuelcoin_balance == 1);
-    assert(balance_test_contract_balance == 3);
+            fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
+            let balance_test_contract_balance = balance_of(fuelcoin_id, balance_test_id);
+            assert(fuelcoin_balance == 1);
+            assert(balance_test_contract_balance == 3);
 
-    true
-}
-"#,
+            true
+        }
+        "#},
         &mut formatter,
     );
 }
@@ -587,1362 +637,1448 @@ fn main() -> bool {
 #[test]
 fn struct_comments() {
     check(
-        r"contract;
-// This is a comment, for this one to be placed correctly we need to have Module visitor implemented
-pub struct Foo { // Here is a comment
-
+        indoc! {r#"
+        contract;
+        // This is a comment, for this one to be placed correctly we need to have Module visitor implemented
+        pub struct Foo { // Here is a comment
 
 
-    // Trying some ASCII art
-    baz:u64,
 
+            // Trying some ASCII art
+            baz:u64,
 
 
 
-    bazzz:u64
-             //  ________ ___  ___  _______   ___               ___       ________  ________  ________
-             // |\  _____\\  \|\  \|\  ___ \ |\  \             |\  \     |\   __  \|\   __  \|\   ____\
-             // \ \  \__/\ \  \\\  \ \   __/|\ \  \            \ \  \    \ \  \|\  \ \  \|\ /\ \  \___|_
-             //  \ \   __\\ \  \\\  \ \  \_|/_\ \  \            \ \  \    \ \   __  \ \   __  \ \_____  \
-             //   \ \  \_| \ \  \\\  \ \  \_|\ \ \  \____        \ \  \____\ \  \ \  \ \  \|\  \|____|\  \
-             //    \ \__\   \ \_______\ \_______\ \_______\       \ \_______\ \__\ \__\ \_______\____\_\  \
-             //     \|__|    \|_______|\|_______|\|_______|        \|_______|\|__|\|__|\|_______|\_________\
-             //                                                                                  \|_________|
-}
-",
-        r"contract;
-// This is a comment, for this one to be placed correctly we need to have Module visitor implemented
-pub struct Foo { // Here is a comment
 
-    // Trying some ASCII art
-    baz: u64,
-    bazzz: u64,
-    //  ________ ___  ___  _______   ___               ___       ________  ________  ________
-    // |\  _____\\  \|\  \|\  ___ \ |\  \             |\  \     |\   __  \|\   __  \|\   ____\
-    // \ \  \__/\ \  \\\  \ \   __/|\ \  \            \ \  \    \ \  \|\  \ \  \|\ /\ \  \___|_
-    //  \ \   __\\ \  \\\  \ \  \_|/_\ \  \            \ \  \    \ \   __  \ \   __  \ \_____  \
-    //   \ \  \_| \ \  \\\  \ \  \_|\ \ \  \____        \ \  \____\ \  \ \  \ \  \|\  \|____|\  \
-    //    \ \__\   \ \_______\ \_______\ \_______\       \ \_______\ \__\ \__\ \_______\____\_\  \
-    //     \|__|    \|_______|\|_______|\|_______|        \|_______|\|__|\|__|\|_______|\_________\
-    //                                                                                  \|_________|
-}
-",
+            bazzz:u64
+                     //  ________ ___  ___  _______   ___               ___       ________  ________  ________
+                     // |\  _____\\  \|\  \|\  ___ \ |\  \             |\  \     |\   __  \|\   __  \|\   ____\
+                     // \ \  \__/\ \  \\\  \ \   __/|\ \  \            \ \  \    \ \  \|\  \ \  \|\ /\ \  \___|_
+                     //  \ \   __\\ \  \\\  \ \  \_|/_\ \  \            \ \  \    \ \   __  \ \   __  \ \_____  \
+                     //   \ \  \_| \ \  \\\  \ \  \_|\ \ \  \____        \ \  \____\ \  \ \  \ \  \|\  \|____|\  \
+                     //    \ \__\   \ \_______\ \_______\ \_______\       \ \_______\ \__\ \__\ \_______\____\_\  \
+                     //     \|__|    \|_______|\|_______|\|_______|        \|_______|\|__|\|__|\|_______|\_________\
+                     //                                                                                  \|_________|
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        // This is a comment, for this one to be placed correctly we need to have Module visitor implemented
+        pub struct Foo { // Here is a comment
+
+            // Trying some ASCII art
+            baz: u64,
+            bazzz: u64,
+            //  ________ ___  ___  _______   ___               ___       ________  ________  ________
+            // |\  _____\\  \|\  \|\  ___ \ |\  \             |\  \     |\   __  \|\   __  \|\   ____\
+            // \ \  \__/\ \  \\\  \ \   __/|\ \  \            \ \  \    \ \  \|\  \ \  \|\ /\ \  \___|_
+            //  \ \   __\\ \  \\\  \ \  \_|/_\ \  \            \ \  \    \ \   __  \ \   __  \ \_____  \
+            //   \ \  \_| \ \  \\\  \ \  \_|\ \ \  \____        \ \  \____\ \  \ \  \ \  \|\  \|____|\  \
+            //    \ \__\   \ \_______\ \_______\ \_______\       \ \_______\ \__\ \__\ \_______\____\_\  \
+            //     \|__|    \|_______|\|_______|\|_______|        \|_______|\|__|\|__|\|_______|\_________\
+            //                                                                                  \|_________|
+        }
+        "#},
     );
 }
 
 #[test]
 fn comments_empty_struct() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-struct AlignMyComments {
-    // Align here please
-        // Overindented comment
-// Underindented comment
-}"#,
-        r#"contract;
-
-struct AlignMyComments {
-    // Align here please
-    // Overindented comment
-    // Underindented comment
-}
-"#,
+        struct AlignMyComments {
+            // Align here please
+                // Overindented comment
+        // Underindented comment
+        }"#},
+        indoc! {r#"
+        contract;
+
+        struct AlignMyComments {
+            // Align here please
+            // Overindented comment
+            // Underindented comment
+        }
+        "#},
     );
 }
 
 #[test]
 fn comments_empty_traits() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-trait AlignMyComments {
-    // Align here please
-        // Overindented comment
-// Underindented comment
-}"#,
-        r#"contract;
-
-trait AlignMyComments {
-    // Align here please
-    // Overindented comment
-    // Underindented comment
-}
-"#,
+        trait AlignMyComments {
+            // Align here please
+                // Overindented comment
+        // Underindented comment
+        }"#},
+        indoc! {r#"
+        contract;
+
+        trait AlignMyComments {
+            // Align here please
+            // Overindented comment
+            // Underindented comment
+        }
+        "#},
     );
 }
 
 #[test]
 fn comments_empty_fns() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-fn single_comment_same_line() { /* a comment */ }
+        fn single_comment_same_line() { /* a comment */ }
 
-fn single_comment_same_line_trailing() {  // a comment
-}
+        fn single_comment_same_line_trailing() {  // a comment
+        }
 
-fn single_comment() -> bool {
-    // TODO: This is a TODO
-}
+        fn single_comment() -> bool {
+            // TODO: This is a TODO
+        }
 
-fn multiline_comments() {
-    // Multi
-        // line
-// comment
-}"#,
-        r#"contract;
+        fn multiline_comments() {
+            // Multi
+                // line
+        // comment
+        }"#},
+        indoc! {r#"
+        contract;
 
-fn single_comment_same_line() { /* a comment */ }
+        fn single_comment_same_line() { /* a comment */ }
 
-fn single_comment_same_line_trailing() { // a comment
-}
+        fn single_comment_same_line_trailing() { // a comment
+        }
 
-fn single_comment() -> bool {
-    // TODO: This is a TODO
-}
+        fn single_comment() -> bool {
+            // TODO: This is a TODO
+        }
 
-fn multiline_comments() {
-    // Multi
-    // line
-    // comment
-}
-"#,
+        fn multiline_comments() {
+            // Multi
+            // line
+            // comment
+        }
+        "#},
     );
 }
 
 #[test]
 fn enum_comments() {
     check(
-        r#"contract;
-pub enum Bazz { // Here is a comment
-    // Trying some ASCII art
-    baz: (),
+        indoc! {r#"
+        contract;
+        pub enum Bazz { // Here is a comment
+            // Trying some ASCII art
+            baz: (),
 
 
 
 
 
-    bazzz: (),//-----
-              //--D--
-              //-----
-}
-"#,
-        r#"contract;
-pub enum Bazz { // Here is a comment
-    // Trying some ASCII art
-    baz: (),
-    bazzz: (), //-----
-    //--D--
-    //-----
-}
-"#,
+            bazzz: (),//-----
+                      //--D--
+                      //-----
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        pub enum Bazz { // Here is a comment
+            // Trying some ASCII art
+            baz: (),
+            bazzz: (), //-----
+            //--D--
+            //-----
+        }
+        "#},
     );
 }
 
 #[test]
 fn fn_comments() {
     check(
-        r#"contract;
-// This is a comment before a fn
-// This is another comment before a fn
-fn hello_world( baz: /* this is a comment */ u64) { let x = 5; // This is a comment inside the block
-}
-"#,
-        r#"contract;
-// This is a comment before a fn
-// This is another comment before a fn
-fn hello_world(baz: /* this is a comment */ u64) {
-    let x = 5; // This is a comment inside the block
-}
-"#,
+        indoc! {r#"
+        contract;
+        // This is a comment before a fn
+        // This is another comment before a fn
+        fn hello_world( baz: /* this is a comment */ u64) { let x = 5; // This is a comment inside the block
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        // This is a comment before a fn
+        // This is another comment before a fn
+        fn hello_world(baz: /* this is a comment */ u64) {
+            let x = 5; // This is a comment inside the block
+        }
+        "#},
     );
 }
 
 #[test]
 fn abi_comments() {
     check(
-        r#"contract;
-
-// This is an abi
-abi StorageMapExample {
-    // insert_into_map is blah blah
-    #[storage(write)] // this is some other comment
-    fn insert_into_map(key: u64, value: u64);
-    // this is the last comment inside the StorageMapExample
-}
+        indoc! {r#"
+        contract;
 
-// This is another abi
-abi AnotherAbi {
-    // insert_into_map is blah blah
-    #[storage(write)]
-    fn update_map(key: u64, value: u64);
-        // this is some other comment
-    fn read(key: u64);
-}
+        // This is an abi
+        abi StorageMapExample {
+            // insert_into_map is blah blah
+            #[storage(write)] // this is some other comment
+            fn insert_into_map(key: u64, value: u64);
+            // this is the last comment inside the StorageMapExample
+        }
 
-abi CommentsInBetween {
-    fn foo();
-    // This should not collapse below
+        // This is another abi
+        abi AnotherAbi {
+            // insert_into_map is blah blah
+            #[storage(write)]
+            fn update_map(key: u64, value: u64);
+                // this is some other comment
+            fn read(key: u64);
+        }
 
-    // this is a comment
-    fn bar();
-}
+        abi CommentsInBetween {
+            fn foo();
+            // This should not collapse below
 
-// This is another abi
-abi Empty {
-    // Empty abi
-}
-"#,
-        r#"contract;
+            // this is a comment
+            fn bar();
+        }
 
-// This is an abi
-abi StorageMapExample {
-    // insert_into_map is blah blah
-    #[storage(write)] // this is some other comment
-    fn insert_into_map(key: u64, value: u64);
-    // this is the last comment inside the StorageMapExample
-}
+        // This is another abi
+        abi Empty {
+            // Empty abi
+        }
+        "#},
+        indoc! {r#"
+        contract;
+
+        // This is an abi
+        abi StorageMapExample {
+            // insert_into_map is blah blah
+            #[storage(write)] // this is some other comment
+            fn insert_into_map(key: u64, value: u64);
+            // this is the last comment inside the StorageMapExample
+        }
 
-// This is another abi
-abi AnotherAbi {
-    // insert_into_map is blah blah
-    #[storage(write)]
-    fn update_map(key: u64, value: u64);
-    // this is some other comment
-    fn read(key: u64);
-}
+        // This is another abi
+        abi AnotherAbi {
+            // insert_into_map is blah blah
+            #[storage(write)]
+            fn update_map(key: u64, value: u64);
+            // this is some other comment
+            fn read(key: u64);
+        }
 
-abi CommentsInBetween {
-    fn foo();
-    // This should not collapse below
+        abi CommentsInBetween {
+            fn foo();
+            // This should not collapse below
 
-    // this is a comment
-    fn bar();
-}
+            // this is a comment
+            fn bar();
+        }
 
-// This is another abi
-abi Empty {
-    // Empty abi
-}
-"#,
+        // This is another abi
+        abi Empty {
+            // Empty abi
+        }
+        "#},
     );
 }
 
 #[test]
 fn const_comments() {
     check(
-        r#"contract;
-pub const /* TEST: blah blah tests */ TEST: u16 = 10; // This is a comment next to a const"#,
-        r#"contract;
-pub const /* TEST: blah blah tests */ TEST: u16 = 10; // This is a comment next to a const
-"#,
+        indoc! {r#"
+        contract;
+        pub const /* TEST: blah blah tests */ TEST: u16 = 10; // This is a comment next to a const"#},
+        indoc! {r#"
+        contract;
+        pub const /* TEST: blah blah tests */ TEST: u16 = 10; // This is a comment next to a const
+        "#},
     );
 }
+
 #[test]
 fn storage_comments() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-struct Type1 {
-    foo: u64,
-}
-struct Type2 {
-    bar: u64,
-}
-storage {
-    // Testing a comment inside storage
-    long_var_name: Type1=Type1{ foo: 8},
-    // Testing another comment
-    var2: Type2 = Type2{bar:9} // This is the last comment
-}"#,
-        r#"contract;
+        struct Type1 {
+            foo: u64,
+        }
+        struct Type2 {
+            bar: u64,
+        }
+        storage {
+            // Testing a comment inside storage
+            long_var_name: Type1=Type1{ foo: 8},
+            // Testing another comment
+            var2: Type2 = Type2{bar:9} // This is the last comment
+        }"#},
+        indoc! {r#"
+        contract;
 
-struct Type1 {
-    foo: u64,
-}
-struct Type2 {
-    bar: u64,
-}
-storage {
-    // Testing a comment inside storage
-    long_var_name: Type1 = Type1 { foo: 8 },
-    // Testing another comment
-    var2: Type2 = Type2 { bar: 9 }, // This is the last comment
-}
-"#,
+        struct Type1 {
+            foo: u64,
+        }
+        struct Type2 {
+            bar: u64,
+        }
+        storage {
+            // Testing a comment inside storage
+            long_var_name: Type1 = Type1 { foo: 8 },
+            // Testing another comment
+            var2: Type2 = Type2 { bar: 9 }, // This is the last comment
+        }
+        "#},
     );
 }
 
 #[test]
 fn trait_comments() {
     check(
-        r#"contract;
-// This is the programmer trait
-trait Programmer {
-    // Returns fav languages of this Programmer.
-    fn fav_language(self) -> String;
-}"#,
-        r#"contract;
-// This is the programmer trait
-trait Programmer {
-    // Returns fav languages of this Programmer.
-    fn fav_language(self) -> String;
-}
-"#,
+        indoc! {r#"
+        contract;
+        // This is the programmer trait
+        trait Programmer {
+            // Returns fav languages of this Programmer.
+            fn fav_language(self) -> String;
+        }"#},
+        indoc! {r#"
+        contract;
+        // This is the programmer trait
+        trait Programmer {
+            // Returns fav languages of this Programmer.
+            fn fav_language(self) -> String;
+        }
+        "#},
     );
 }
 
 #[test]
 fn where_comment() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-pub fn hello( person: String ) -> String where /* This is next to where */ T: Eq, /*Here is a comment*/{let greeting = 42;greeting.to_string()}"#,
-        r#"contract;
+        pub fn hello( person: String ) -> String where /* This is next to where */ T: Eq, /*Here is a comment*/{let greeting = 42;greeting.to_string()}"#},
+        indoc! {r#"
+        contract;
 
-pub fn hello(person: String) -> String
-where /* This is next to where */
-    T: Eq, /*Here is a comment*/
-{
-    let greeting = 42;
-    greeting.to_string()
-}
-"#,
+        pub fn hello(person: String) -> String
+        where /* This is next to where */
+            T: Eq, /*Here is a comment*/
+        {
+            let greeting = 42;
+            greeting.to_string()
+        }
+        "#},
     );
 }
+
 #[test]
 fn impl_spacing() {
     check(
-        r#"script;
-
-struct Foo {
-    bar: u64,
-    baz: bool,
-}
+        indoc! {r#"
+        script;
 
-trait Qux {
-    fn is_baz_true(self) -> bool;
-}
+        struct Foo {
+            bar: u64,
+            baz: bool,
+        }
 
-impl<A ,     B>    Qux<A, B> for
-Foo
-where
-    A    : Qux,
-    B: Qux    ,
-{fn is_baz_true(self) -> bool {
-        self.baz
-    }}"#,
-        r#"script;
+        trait Qux {
+            fn is_baz_true(self) -> bool;
+        }
 
-struct Foo {
-    bar: u64,
-    baz: bool,
-}
+        impl<A ,     B>    Qux<A, B> for
+        Foo
+        where
+            A    : Qux,
+            B: Qux    ,
+        {fn is_baz_true(self) -> bool {
+                self.baz
+            }}"#},
+        indoc! {r#"
+        script;
+
+        struct Foo {
+            bar: u64,
+            baz: bool,
+        }
 
-trait Qux {
-    fn is_baz_true(self) -> bool;
-}
+        trait Qux {
+            fn is_baz_true(self) -> bool;
+        }
 
-impl<A, B> Qux<A, B> for Foo
-where
-    A: Qux,
-    B: Qux,
-{
-    fn is_baz_true(self) -> bool {
-        self.baz
-    }
-}
-"#,
+        impl<A, B> Qux<A, B> for Foo
+        where
+            A: Qux,
+            B: Qux,
+        {
+            fn is_baz_true(self) -> bool {
+                self.baz
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn impl_without_generics() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
-struct Foo {
-    bar: u64,
-    baz: bool,
-}
+        struct Foo {
+            bar: u64,
+            baz: bool,
+        }
 
-trait Qux {
-    fn is_baz_true(self) -> bool;
-}
+        trait Qux {
+            fn is_baz_true(self) -> bool;
+        }
 
-impl   Qux for
-Foo
-{fn is_baz_true(self) -> bool {
-        self.baz
-    }}"#,
-        r#"script;
+        impl   Qux for
+        Foo
+        {fn is_baz_true(self) -> bool {
+                self.baz
+            }}"#},
+        indoc! {r#"
+        script;
 
-struct Foo {
-    bar: u64,
-    baz: bool,
-}
+        struct Foo {
+            bar: u64,
+            baz: bool,
+        }
 
-trait Qux {
-    fn is_baz_true(self) -> bool;
-}
+        trait Qux {
+            fn is_baz_true(self) -> bool;
+        }
 
-impl Qux for Foo {
-    fn is_baz_true(self) -> bool {
-        self.baz
-    }
-}
-"#,
+        impl Qux for Foo {
+            fn is_baz_true(self) -> bool {
+                self.baz
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn newline_sequence_formatting() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
-fn main() {
-    let number: u64 = 10;
+        fn main() {
+            let number: u64 = 10;
 
-    let number2: u64 = 20;
+            let number2: u64 = 20;
 
 
 
-    let number3: u64 = 30;
+            let number3: u64 = 30;
 
 
 
-}"#,
-        r#"script;
+        }"#},
+        indoc! {r#"
+        script;
 
-fn main() {
-    let number: u64 = 10;
+        fn main() {
+            let number: u64 = 10;
 
-    let number2: u64 = 20;
+            let number2: u64 = 20;
 
-    let number3: u64 = 30;
-}
-"#,
+            let number3: u64 = 30;
+        }
+        "#},
     );
 }
 
 #[test]
 fn inner_doc_comments() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
-enum Color {
-    //! Color is a Sway enum
-    blue: (),
-    red: ()
-}
-
-fn main() {
-}"#,
-        r#"script;
+        enum Color {
+            //! Color is a Sway enum
+            blue: (),
+            red: ()
+        }
 
-enum Color {
-    //! Color is a Sway enum
-    blue: (),
-    red: (),
-}
+        fn main() {
+        }"#},
+        indoc! {r#"
+        script;
+
+        enum Color {
+            //! Color is a Sway enum
+            blue: (),
+            red: (),
+        }
 
-fn main() {}
-"#,
+        fn main() {}
+        "#},
     );
 }
 
 #[test]
 fn outer_doc_comments() {
     check(
-        r#"script;
-
-enum Color {
-    /// Blue color
-    blue: (),
-    /// Red color
-    red: ()
-}
-/// This is the main function
-fn main() {
-}"#,
-        r#"script;
+        indoc! {r#"
+        script;
 
-enum Color {
-    /// Blue color
-    blue: (),
-    /// Red color
-    red: (),
-}
-/// This is the main function
-fn main() {}
-"#,
+        enum Color {
+            /// Blue color
+            blue: (),
+            /// Red color
+            red: ()
+        }
+        /// This is the main function
+        fn main() {
+        }"#},
+        indoc! {r#"
+        script;
+
+        enum Color {
+            /// Blue color
+            blue: (),
+            /// Red color
+            red: (),
+        }
+        /// This is the main function
+        fn main() {}
+        "#},
     );
 }
 
 #[test]
 fn newline_comment_handler_interaction() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
-// use statements
-use std::*;
+        // use statements
+        use std::*;
 
-fn main() {
-    // Array of integers with type ascription
-let array_of_integers: [u8;
-5] = [1, 2, 3, 4, 5];
+        fn main() {
+            // Array of integers with type ascription
+        let array_of_integers: [u8;
+        5] = [1, 2, 3, 4, 5];
 
 
-    // Array of strings
-    let array_of_strings = [ "Bob", "Jan", "Ron"];
-}
-"#,
-        r#"script;
+            // Array of strings
+            let array_of_strings = [ "Bob", "Jan", "Ron"];
+        }
+        "#},
+        indoc! {r#"
+        script;
 
-// use statements
-use std::*;
+        // use statements
+        use std::*;
 
-fn main() {
-    // Array of integers with type ascription
-    let array_of_integers: [u8; 5] = [1, 2, 3, 4, 5];
+        fn main() {
+            // Array of integers with type ascription
+            let array_of_integers: [u8; 5] = [1, 2, 3, 4, 5];
 
-    // Array of strings
-    let array_of_strings = ["Bob", "Jan", "Ron"];
-}
-"#,
+            // Array of strings
+            let array_of_strings = ["Bob", "Jan", "Ron"];
+        }
+        "#},
     );
 }
+
 #[test]
 fn comments_before_module_kind() {
     check(
-        r#"// something about module kind
-// something else about module kind
-library;"#,
-        r#"// something about module kind
-// something else about module kind
-library;
-"#,
+        indoc! {r#"
+        // something about module kind
+        // something else about module kind
+        library;"#},
+        indoc! {r#"
+        // something about module kind
+        // something else about module kind
+        library;
+        "#},
     );
 }
+
 #[test]
 fn newline_before_comments() {
     check(
-        r#"
+        indoc! {r#"
 
 
-// something about module kind
-// something else about module kind
-library;"#,
-        r#"// something about module kind
-// something else about module kind
-library;
-"#,
+        // something about module kind
+        // something else about module kind
+        library;"#},
+        indoc! {r#"
+        // something about module kind
+        // something else about module kind
+        library;
+        "#},
     );
 }
+
 #[test]
 fn destructure_structs() {
     check(
-        r#"library;
-
-struct Point {
-    x: u64,
-    y: u64,
-}
-struct TupleInStruct {
-    nested_tuple: (u64, (u32, (bool, str[2]))),
-}
-fn struct_destructuring() {
-    let point1 = Point { x: 0, y: 0 };
-    let Point{x, y} = point1;
-    let point2 = Point { x: 18446744073709551615, y: 18446744073709551615};
-    let Point{extremely_long_var_name, other_really_long_var_name} = point2;
-    let tuple_in_struct = TupleInStruct {
-        nested_tuple: (
-            42u64,
-            (42u32, (true, "ok"))
-        ),
-    };
-    let TupleInStruct {
-        nested_tuple: (a, (b, (c, d))),
-    } = tuple_in_struct;
-}
-"#,
-        r#"library;
-
-struct Point {
-    x: u64,
-    y: u64,
-}
-struct TupleInStruct {
-    nested_tuple: (u64, (u32, (bool, str[2]))),
-}
-fn struct_destructuring() {
-    let point1 = Point { x: 0, y: 0 };
-    let Point { x, y } = point1;
-    let point2 = Point {
-        x: 18446744073709551615,
-        y: 18446744073709551615,
-    };
-    let Point {
-        extremely_long_var_name,
-        other_really_long_var_name,
-    } = point2;
-    let tuple_in_struct = TupleInStruct {
-        nested_tuple: (42u64, (42u32, (true, "ok"))),
-    };
-    let TupleInStruct {
-        nested_tuple: (a, (b, (c, d))),
-    } = tuple_in_struct;
-}
-"#,
-    );
+        indoc! {r#"
+        library;
+
+        struct Point {
+            x: u64,
+            y: u64,
+        }
+        struct TupleInStruct {
+            nested_tuple: (u64, (u32, (bool, str[2]))),
+        }
+        fn struct_destructuring() {
+            let point1 = Point { x: 0, y: 0 };
+            let Point{x, y} = point1;
+            let point2 = Point { x: 18446744073709551615, y: 18446744073709551615};
+            let Point{extremely_long_var_name, other_really_long_var_name} = point2;
+            let tuple_in_struct = TupleInStruct {
+                nested_tuple: (
+                    42u64,
+                    (42u32, (true, "ok"))
+                ),
+            };
+            let TupleInStruct {
+                nested_tuple: (a, (b, (c, d))),
+            } = tuple_in_struct;
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        struct Point {
+            x: u64,
+            y: u64,
+        }
+        struct TupleInStruct {
+            nested_tuple: (u64, (u32, (bool, str[2]))),
+        }
+        fn struct_destructuring() {
+            let point1 = Point { x: 0, y: 0 };
+            let Point { x, y } = point1;
+            let point2 = Point {
+                x: 18446744073709551615,
+                y: 18446744073709551615,
+            };
+            let Point {
+                extremely_long_var_name,
+                other_really_long_var_name,
+            } = point2;
+            let tuple_in_struct = TupleInStruct {
+                nested_tuple: (42u64, (42u32, (true, "ok"))),
+            };
+            let TupleInStruct {
+                nested_tuple: (a, (b, (c, d))),
+            } = tuple_in_struct;
+        }
+        "#},
+    );
 }
+
 #[test]
 fn multiline_collections() {
     check(
-        r#"library;
-fn func_with_multiline_collections() {
-    let x = (
-        "hello",
-        "world",
-    );
-}
-"#,
-        r#"library;
-fn func_with_multiline_collections() {
-    let x = ("hello", "world");
-}
-"#,
+        indoc! {r#"
+        library;
+        fn func_with_multiline_collections() {
+            let x = (
+                "hello",
+                "world",
+            );
+        }
+        "#},
+        indoc! {r#"
+        library;
+        fn func_with_multiline_collections() {
+            let x = ("hello", "world");
+        }
+        "#},
     );
 }
 
 #[test]
 fn comments_between_if_else() {
     check(
-        r#"script;
-
-fn main() {
-    if pledge_history_index != 0 {
-        // This is a comment
-        storage.pledge_history.insert((user, pledge_history_index), pledge);
-    }
-    // This is also a comment,
-    // but multiline
-    else if true {
-        // This is yet another comment
-        storage.pledge_count.insert(user, pledge_count + 1);
-    }
-    // This is the last comment
-    else {
-        storage.pledge_count.insert(user, pledge_count + 1);
-    }
-}
-"#,
-        r#"script;
-
-fn main() {
-    if pledge_history_index != 0 {
-        // This is a comment
-        storage
-            .pledge_history
-            .insert((user, pledge_history_index), pledge);
-    }
-    // This is also a comment,
-    // but multiline
-    else if true {
-        // This is yet another comment
-        storage.pledge_count.insert(user, pledge_count + 1);
-    }
-    // This is the last comment
-    else {
-        storage.pledge_count.insert(user, pledge_count + 1);
-    }
-}
-"#,
+        indoc! {r#"
+        script;
+
+        fn main() {
+            if pledge_history_index != 0 {
+                // This is a comment
+                storage.pledge_history.insert((user, pledge_history_index), pledge);
+            }
+            // This is also a comment,
+            // but multiline
+            else if true {
+                // This is yet another comment
+                storage.pledge_count.insert(user, pledge_count + 1);
+            }
+            // This is the last comment
+            else {
+                storage.pledge_count.insert(user, pledge_count + 1);
+            }
+        }
+        "#},
+        indoc! {r#"
+        script;
+
+        fn main() {
+            if pledge_history_index != 0 {
+                // This is a comment
+                storage
+                    .pledge_history
+                    .insert((user, pledge_history_index), pledge);
+            }
+            // This is also a comment,
+            // but multiline
+            else if true {
+                // This is yet another comment
+                storage.pledge_count.insert(user, pledge_count + 1);
+            }
+            // This is the last comment
+            else {
+                storage.pledge_count.insert(user, pledge_count + 1);
+            }
+        }
+        "#},
     );
 }
+
 #[test]
 fn parameterless_attributes() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-abi MyContract {
-    #[test]
-    fn foo();
-}
-"#,
-        r#"library;
+        abi MyContract {
+            #[test]
+            fn foo();
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-abi MyContract {
-    #[test]
-    fn foo();
-}
-"#,
+        abi MyContract {
+            #[test]
+            fn foo();
+        }
+        "#},
     );
 }
 
 #[test]
 fn traits_with_def_block() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
-pub trait Foo {
-    fn foo(self, other: Self);
-} {
-    fn bar(self, other: Self) {}
-}
+        pub trait Foo {
+            fn foo(self, other: Self);
+        } {
+            fn bar(self, other: Self) {}
+        }
 
-fn main() {}
-"#,
-        r#"script;
+        fn main() {}
+        "#},
+        indoc! {r#"
+        script;
 
-pub trait Foo {
-    fn foo(self, other: Self);
-} {
-    fn bar(self, other: Self) {}
-}
+        pub trait Foo {
+            fn foo(self, other: Self);
+        } {
+            fn bar(self, other: Self) {}
+        }
 
-fn main() {}
-"#,
+        fn main() {}
+        "#},
     );
 }
 
 #[test]
 fn if_else_multiline_to_inline() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
-fn main() {
-    if foo    {
-           let x = 1;
-    } else    {
-        bar(y)   ;
-    }
-}
-"#,
-        r#"script;
+        fn main() {
+            if foo    {
+                   let x = 1;
+            } else    {
+                bar(y)   ;
+            }
+        }
+        "#},
+        indoc! {r#"
+        script;
 
-fn main() {
-    if foo { let x = 1; } else { bar(y); }
-}
-"#,
+        fn main() {
+            if foo { let x = 1; } else { bar(y); }
+        }
+        "#},
     );
 }
 
 #[test]
 fn if_else_retain_multiline() {
     check(
-        r#"script;
+        indoc! {r#"
+        script;
 
 
-fn main() {
-    if foo    {
-           let really_long_variable = 1;
-    } else    {
-        bar(y)   ;
-    }
-}
-"#,
-        r#"script;
+        fn main() {
+            if foo    {
+                   let really_long_variable = 1;
+            } else    {
+                bar(y)   ;
+            }
+        }
+        "#},
+        indoc! {r#"
+        script;
 
-fn main() {
-    if foo {
-        let really_long_variable = 1;
-    } else {
-        bar(y);
-    }
-}
-"#,
+        fn main() {
+            if foo {
+                let really_long_variable = 1;
+            } else {
+                bar(y);
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn multiple_comma_separated_attributes() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-#[test, inline(always), storage(read, write), payable]
-fn foo() {}
-"#,
-        r#"library;
+        #[test, inline(always), storage(read, write), payable]
+        fn foo() {}
+        "#},
+        indoc! {r#"
+        library;
 
-#[test, inline(always), storage(read, write), payable]
-fn foo() {}
-"#,
+        #[test, inline(always), storage(read, write), payable]
+        fn foo() {}
+        "#},
     );
 }
 
 #[test]
 fn stack_of_comma_separated_attributes1() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-/// this is a doc comment
-#[storage(read, write), payable]
-#[test, inline(always)]
-fn foo() {}
-"#,
-        r#"library;
+        /// this is a doc comment
+        #[storage(read, write), payable]
+        #[test, inline(always)]
+        fn foo() {}
+        "#},
+        indoc! {r#"
+        library;
 
-/// this is a doc comment
-#[storage(read, write), payable]
-#[test, inline(always)]
-fn foo() {}
-"#,
+        /// this is a doc comment
+        #[storage(read, write), payable]
+        #[test, inline(always)]
+        fn foo() {}
+        "#},
     );
 }
 
 #[test]
 fn stack_of_comma_separated_attributes2() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-/// this is a doc comment
-#[storage(read, write)]
-#[payable]
-#[test]
-#[inline(always)]
-fn foo() {}
-"#,
-        r#"library;
+        /// this is a doc comment
+        #[storage(read, write)]
+        #[payable]
+        #[test]
+        #[inline(always)]
+        fn foo() {}
+        "#},
+        indoc! {r#"
+        library;
 
-/// this is a doc comment
-#[storage(read, write)]
-#[payable]
-#[test]
-#[inline(always)]
-fn foo() {}
-"#,
+        /// this is a doc comment
+        #[storage(read, write)]
+        #[payable]
+        #[test]
+        #[inline(always)]
+        fn foo() {}
+        "#},
     );
 }
 
 #[test]
 fn comment_between_closing_brace_and_else() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-impl MyContract for Contract {
-    fn is_blue() -> bool {
-        if self == PrimaryColor::Blue {
-            true
-        }
-            // Overindented comment, underindented else
-    else if self == PrimaryColor::Red {
-            true
-        } // Trailing comment
-    // Underindented comment
-            // Overindented else
+        impl MyContract for Contract {
+            fn is_blue() -> bool {
+                if self == PrimaryColor::Blue {
+                    true
+                }
+                    // Overindented comment, underindented else
+            else if self == PrimaryColor::Red {
+                    true
+                } // Trailing comment
+            // Underindented comment
+                    // Overindented else
+                        else {
+                    false
+                }
+            }
+        }"#},
+        indoc! {r#"
+        contract;
+
+        impl MyContract for Contract {
+            fn is_blue() -> bool {
+                if self == PrimaryColor::Blue {
+                    true
+                }
+                // Overindented comment, underindented else
+                else if self == PrimaryColor::Red {
+                    true
+                } // Trailing comment
+                // Underindented comment
+                // Overindented else
                 else {
-            false
-        }
-    }
-}"#,
-        r#"contract;
-
-impl MyContract for Contract {
-    fn is_blue() -> bool {
-        if self == PrimaryColor::Blue {
-            true
-        }
-        // Overindented comment, underindented else
-        else if self == PrimaryColor::Red {
-            true
-        } // Trailing comment
-        // Underindented comment
-        // Overindented else
-        else {
-            false
+                    false
+                }
+            }
         }
-    }
-}
-"#,
+        "#},
     );
 }
 
 #[test]
 fn comment_between_if_else_inline_to_multiline() {
     check(
-        r#"contract;
-
-impl MyContract for Contract {
-    fn is_blue() -> bool {
-            if self == PrimaryColor::Blue { true }
-        // TODO remove this else when exhaustive ifs are checked for
-    else { false }
-    }
-}"#,
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-impl MyContract for Contract {
-    fn is_blue() -> bool {
-        if self == PrimaryColor::Blue {
-            true
-        }
-        // TODO remove this else when exhaustive ifs are checked for
-        else {
-            false
+        impl MyContract for Contract {
+            fn is_blue() -> bool {
+                    if self == PrimaryColor::Blue { true }
+                // TODO remove this else when exhaustive ifs are checked for
+            else { false }
+            }
+        }"#},
+        indoc! {r#"
+        contract;
+
+        impl MyContract for Contract {
+            fn is_blue() -> bool {
+                if self == PrimaryColor::Blue {
+                    true
+                }
+                // TODO remove this else when exhaustive ifs are checked for
+                else {
+                    false
+                }
+            }
         }
-    }
-}
-"#,
+        "#},
     );
 }
 
 #[test]
 fn asm_block() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-fn foo() {
-    asm(r1: self, r2: other, r3, r4) {
-        addi r3 zero i32;
-        meq r4 r1 r2 r3;
-        r4: bool
-    }
-}
-"#,
-        r#"library;
+        fn foo() {
+            asm(r1: self, r2: other, r3, r4) {
+                addi r3 zero i32;
+                meq r4 r1 r2 r3;
+                r4: bool
+            }
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn foo() {
-    asm(r1: self, r2: other, r3, r4) {
-        addi r3 zero i32;
-        meq r4 r1 r2 r3;
-        r4: bool
-    }
-}
-"#,
+        fn foo() {
+            asm(r1: self, r2: other, r3, r4) {
+                addi r3 zero i32;
+                meq r4 r1 r2 r3;
+                r4: bool
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn empty_blocks() {
     check(
-        r#"contract;
-
-fn contents() {
-    let i = {    };
-    match i {
-    }
-    if true {    }
-}
-fn empty() {}
-"#,
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-fn contents() {
-    let i = {};
-    match i {}
-    if true {}
-}
-fn empty() {}
-"#,
+        fn contents() {
+            let i = {    };
+            match i {
+            }
+            if true {    }
+        }
+        fn empty() {}
+        "#},
+        indoc! {r#"
+        contract;
+
+        fn contents() {
+            let i = {};
+            match i {}
+            if true {}
+        }
+        fn empty() {}
+        "#},
     );
 }
 
 #[test]
 fn abi_supertrait() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-trait ABIsupertrait {
-    fn foo();
-}
+        trait ABIsupertrait {
+            fn foo();
+        }
 
-abi MyAbi : ABIsupertrait {
-    fn bar();
-} {
-    fn baz() {
-        Self::foo()     // supertrait method usage
-    }
-}
+        abi MyAbi : ABIsupertrait {
+            fn bar();
+        } {
+            fn baz() {
+                Self::foo()     // supertrait method usage
+            }
+        }
 
-impl ABIsupertrait for Contract {
-    fn foo() {}
-}
+        impl ABIsupertrait for Contract {
+            fn foo() {}
+        }
 
-// The implementation of MyAbi for Contract must also implement ABIsupertrait
-impl MyAbi for Contract {
-    fn bar() {
-        Self::foo()     // supertrait method usage
-    }
-}
-"#,
-        r#"contract;
+        // The implementation of MyAbi for Contract must also implement ABIsupertrait
+        impl MyAbi for Contract {
+            fn bar() {
+                Self::foo()     // supertrait method usage
+            }
+        }
+        "#},
+        indoc! {r#"
+        contract;
 
-trait ABIsupertrait {
-    fn foo();
-}
+        trait ABIsupertrait {
+            fn foo();
+        }
 
-abi MyAbi : ABIsupertrait {
-    fn bar();
-} {
-    fn baz() {
-        Self::foo() // supertrait method usage
-    }
-}
+        abi MyAbi : ABIsupertrait {
+            fn bar();
+        } {
+            fn baz() {
+                Self::foo() // supertrait method usage
+            }
+        }
 
-impl ABIsupertrait for Contract {
-    fn foo() {}
-}
+        impl ABIsupertrait for Contract {
+            fn foo() {}
+        }
 
-// The implementation of MyAbi for Contract must also implement ABIsupertrait
-impl MyAbi for Contract {
-    fn bar() {
-        Self::foo() // supertrait method usage
-    }
-}
-"#,
+        // The implementation of MyAbi for Contract must also implement ABIsupertrait
+        impl MyAbi for Contract {
+            fn bar() {
+                Self::foo() // supertrait method usage
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn test_comments_after_deps() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-use std::{u256::U256, vec::*};
-use ::utils::vec::sort;
-use ::utils::numbers::*;
+        use std::{u256::U256, vec::*};
+        use ::utils::vec::sort;
+        use ::utils::numbers::*;
 
-// pub fn aggregate_results(results: Vec<Vec<U256>>) -> Vec<U256> {
-//     let mut aggregated = Vec::new();
+        // pub fn aggregate_results(results: Vec<Vec<U256>>) -> Vec<U256> {
+        //     let mut aggregated = Vec::new();
 
-//     let mut i = 0;
-//     while (i < results.len) {
-//         let values = results.get(i).unwrap();
-//         aggregated.push(aggregate_values(values));
+        //     let mut i = 0;
+        //     while (i < results.len) {
+        //         let values = results.get(i).unwrap();
+        //         aggregated.push(aggregate_values(values));
 
-//         i += 1;
-//     }
+        //         i += 1;
+        //     }
 
-//     return aggregated;
-// }"#,
-        r#"library;
+        //     return aggregated;
+        // }"#},
+        indoc! {r#"
+        library;
 
-use std::{u256::U256, vec::*};
-use ::utils::vec::sort;
-use ::utils::numbers::*;
+        use std::{u256::U256, vec::*};
+        use ::utils::vec::sort;
+        use ::utils::numbers::*;
 
-// pub fn aggregate_results(results: Vec<Vec<U256>>) -> Vec<U256> {
-//     let mut aggregated = Vec::new();
+        // pub fn aggregate_results(results: Vec<Vec<U256>>) -> Vec<U256> {
+        //     let mut aggregated = Vec::new();
 
-//     let mut i = 0;
-//     while (i < results.len) {
-//         let values = results.get(i).unwrap();
-//         aggregated.push(aggregate_values(values));
+        //     let mut i = 0;
+        //     while (i < results.len) {
+        //         let values = results.get(i).unwrap();
+        //         aggregated.push(aggregate_values(values));
 
-//         i += 1;
-//     }
+        //         i += 1;
+        //     }
 
-//     return aggregated;
-// }
-"#,
+        //     return aggregated;
+        // }
+        "#},
     );
 }
 
 #[test]
 fn temporarily_commented_out_fn_with_doc_comments() {
     check(
-        r#"contract;
+        indoc! {r#"
+        contract;
 
-abi MyContract {
-    /// Doc comment
-    /*
-        Some comment
-    */
-    fn test_function() -> bool;
-}
-
-impl MyContract for Contract {
-    /// This is documentation for a commented out function
-    // fn commented_out_function() {
-    //}
+        abi MyContract {
+            /// Doc comment
+            /*
+                Some comment
+            */
+            fn test_function() -> bool;
+        }
 
-    fn test_function() -> bool {
-        true
-    }
-}"#,
-        r#"contract;
+        impl MyContract for Contract {
+            /// This is documentation for a commented out function
+            // fn commented_out_function() {
+            //}
 
-abi MyContract {
-    /// Doc comment
-    /*
-        Some comment
-    */
-    fn test_function() -> bool;
-}
+            fn test_function() -> bool {
+                true
+            }
+        }"#},
+        indoc! {r#"
+        contract;
+
+        abi MyContract {
+            /// Doc comment
+            /*
+                Some comment
+            */
+            fn test_function() -> bool;
+        }
 
-impl MyContract for Contract {
-    /// This is documentation for a commented out function
-    // fn commented_out_function() {
-    //}
+        impl MyContract for Contract {
+            /// This is documentation for a commented out function
+            // fn commented_out_function() {
+            //}
 
-    fn test_function() -> bool {
-        true
-    }
-}
-"#,
+            fn test_function() -> bool {
+                true
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn empty_fn() {
     check(
-        r#"
-library;
-fn test() {
-}
-        "#,
-        r#"library;
-fn test() {}
-"#,
+        indoc! {r#"
+        library;
+        fn test() {
+        }
+        "#},
+        indoc! {r#"
+        library;
+        fn test() {}
+        "#},
     );
 }
 
 #[test]
 fn empty_if() {
     check(
-        r#"
-library;
-fn test() {
-    if ( something ( ) ) {
-    }
-}
-        "#,
-        r#"library;
-fn test() {
-    if (something()) {}
-}
-"#,
+        indoc! {r#"
+        library;
+        fn test() {
+            if ( something ( ) ) {
+            }
+        }
+        "#},
+        indoc! {r#"
+        library;
+        fn test() {
+            if (something()) {}
+        }
+        "#},
     );
 }
 
 #[test]
 fn bug_whitespace_added_after_comment() {
     check(
-        r#"
-library;
-// GTF Opcode const selectors
-//
-pub const GTF_OUTPUT_TYPE = 0x300;
-pub const GTF_OUTPUT_COIN_TO = 0x301;
-pub const GTF_OUTPUT_COIN_AMOUNT = 0x302;
-pub const GTF_OUTPUT_COIN_ASSET_ID = 0x303;
-// pub const GTF_OUTPUT_CONTRACT_INPUT_INDEX = 0x304;
-// pub const GTF_OUTPUT_CONTRACT_BALANCE_ROOT = 0x305;
-// pub const GTF_OUTPUT_CONTRACT_STATE_ROOT = 0x306;
-// pub const GTF_OUTPUT_CONTRACT_CREATED_CONTRACT_ID = 0x307;
-// pub const GTF_OUTPUT_CONTRACT_CREATED_STATE_ROOT = 0x308;
-
-
-
-/// The output type for a transaction.
-pub enum Output {
-    /// A coin output.
-    Coin: (), /// A contract output.
-    Contract: (),
-    /// Remaining "change" from spending of a coin.
-    Change: (),
-        /// A variable output.
-    Variable: (),
-}
-    /// The output type for a transaction.
-pub enum Input {
-        /// A variable output.
+        indoc! {r#"
+        library;
+        // GTF Opcode const selectors
+        //
+        pub const GTF_OUTPUT_TYPE = 0x300;
+        pub const GTF_OUTPUT_COIN_TO = 0x301;
+        pub const GTF_OUTPUT_COIN_AMOUNT = 0x302;
+        pub const GTF_OUTPUT_COIN_ASSET_ID = 0x303;
+        // pub const GTF_OUTPUT_CONTRACT_INPUT_INDEX = 0x304;
+        // pub const GTF_OUTPUT_CONTRACT_BALANCE_ROOT = 0x305;
+        // pub const GTF_OUTPUT_CONTRACT_STATE_ROOT = 0x306;
+        // pub const GTF_OUTPUT_CONTRACT_CREATED_CONTRACT_ID = 0x307;
+        // pub const GTF_OUTPUT_CONTRACT_CREATED_STATE_ROOT = 0x308;
+
+
+
+        /// The output type for a transaction.
+        pub enum Output {
+            /// A coin output.
+            Coin: (), /// A contract output.
+            Contract: (),
+            /// Remaining "change" from spending of a coin.
+            Change: (),
+                /// A variable output.
             Variable: (),
-}
-        "#,
-        r#"library;
-// GTF Opcode const selectors
-//
-pub const GTF_OUTPUT_TYPE = 0x300;
-pub const GTF_OUTPUT_COIN_TO = 0x301;
-pub const GTF_OUTPUT_COIN_AMOUNT = 0x302;
-pub const GTF_OUTPUT_COIN_ASSET_ID = 0x303;
-// pub const GTF_OUTPUT_CONTRACT_INPUT_INDEX = 0x304;
-// pub const GTF_OUTPUT_CONTRACT_BALANCE_ROOT = 0x305;
-// pub const GTF_OUTPUT_CONTRACT_STATE_ROOT = 0x306;
-// pub const GTF_OUTPUT_CONTRACT_CREATED_CONTRACT_ID = 0x307;
-// pub const GTF_OUTPUT_CONTRACT_CREATED_STATE_ROOT = 0x308;
-
-/// The output type for a transaction.
-pub enum Output {
-    /// A coin output.
-    Coin: (),
-    /// A contract output.
-    Contract: (),
-    /// Remaining "change" from spending of a coin.
-    Change: (),
-    /// A variable output.
-    Variable: (),
-}
-/// The output type for a transaction.
-pub enum Input {
-    /// A variable output.
-    Variable: (),
-}
-"#,
+        }
+            /// The output type for a transaction.
+        pub enum Input {
+                /// A variable output.
+                    Variable: (),
+        }
+        "#},
+        indoc! {r#"
+        library;
+        // GTF Opcode const selectors
+        //
+        pub const GTF_OUTPUT_TYPE = 0x300;
+        pub const GTF_OUTPUT_COIN_TO = 0x301;
+        pub const GTF_OUTPUT_COIN_AMOUNT = 0x302;
+        pub const GTF_OUTPUT_COIN_ASSET_ID = 0x303;
+        // pub const GTF_OUTPUT_CONTRACT_INPUT_INDEX = 0x304;
+        // pub const GTF_OUTPUT_CONTRACT_BALANCE_ROOT = 0x305;
+        // pub const GTF_OUTPUT_CONTRACT_STATE_ROOT = 0x306;
+        // pub const GTF_OUTPUT_CONTRACT_CREATED_CONTRACT_ID = 0x307;
+        // pub const GTF_OUTPUT_CONTRACT_CREATED_STATE_ROOT = 0x308;
+
+        /// The output type for a transaction.
+        pub enum Output {
+            /// A coin output.
+            Coin: (),
+            /// A contract output.
+            Contract: (),
+            /// Remaining "change" from spending of a coin.
+            Change: (),
+            /// A variable output.
+            Variable: (),
+        }
+        /// The output type for a transaction.
+        pub enum Input {
+            /// A variable output.
+            Variable: (),
+        }
+        "#},
     );
 }
 
 #[test]
 fn empty_impl() {
     check(
-        r#"
-library;
-impl OrdEq for u256 {
-}
-        "#,
-        r#"library;
-impl OrdEq for u256 {}
-"#,
+        indoc! {r#"
+        library;
+        impl OrdEq for u256 {
+        }
+        "#},
+        indoc! {r#"
+        library;
+        impl OrdEq for u256 {}
+        "#},
     );
 }
 
 #[test]
 fn chained_methods_0() {
     check(
-        r#"
-library;
+        indoc! {r#"
+        library;
 
-fn test() {
-    fuel.really_long_field.other_really_long_field.foo().bar().baz.quux().yet_another_call().to_go_above_max_line_length();
-}
-        "#,
-        r#"library;
+        fn test() {
+            fuel.really_long_field.other_really_long_field.foo().bar().baz.quux().yet_another_call().to_go_above_max_line_length();
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn test() {
-    fuel.really_long_field
-        .other_really_long_field
-        .foo()
-        .bar()
-        .baz
-        .quux()
-        .yet_another_call()
-        .to_go_above_max_line_length();
-}
-"#,
+        fn test() {
+            fuel.really_long_field
+                .other_really_long_field
+                .foo()
+                .bar()
+                .baz
+                .quux()
+                .yet_another_call()
+                .to_go_above_max_line_length();
+        }
+        "#},
     );
 }
 
 #[test]
 fn chained_methods_1() {
     check(
-        r#"
-library;
+        indoc! {r#"
+        library;
 
-fn test() {
-    fuelcoin.really_long_field.other_really_long_field.foo().bar().baz.quux().yet_another_call().to_go_above_max_line_length();
-}
-        "#,
-        r#"library;
+        fn test() {
+            fuelcoin.really_long_field.other_really_long_field.foo().bar().baz.quux().yet_another_call().to_go_above_max_line_length();
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn test() {
-    fuelcoin
-        .really_long_field
-        .other_really_long_field
-        .foo()
-        .bar()
-        .baz
-        .quux()
-        .yet_another_call()
-        .to_go_above_max_line_length();
-}
-"#,
+        fn test() {
+            fuelcoin
+                .really_long_field
+                .other_really_long_field
+                .foo()
+                .bar()
+                .baz
+                .quux()
+                .yet_another_call()
+                .to_go_above_max_line_length();
+        }
+        "#},
     );
 }
 
 #[test]
 fn chained_methods_2() {
     check(
-        r#"
-library;
-
-fn test() {
-    fuelcoin.really_long_field.other_really_long_field.foo().bar().baz.quux([1,2]).yet_another_call([1, 2, 3, 4, 6, 7, 7, 8, 8, 9, 9, 9, 19, 1123123, 12312, 312, 312, 3123, 12,31, 44],[1,2], true).to_go_above_max_line_length();ping();
-}
-        "#,
-        r#"library;
-
-fn test() {
-    fuelcoin
-        .really_long_field
-        .other_really_long_field
-        .foo()
-        .bar()
-        .baz
-        .quux([1, 2])
-        .yet_another_call(
-            [
-                1, 2, 3, 4, 6, 7, 7, 8, 8, 9, 9, 9, 19, 1123123, 12312, 312, 312,
-                3123, 12, 31, 44,
-            ],
-            [1, 2],
-            true,
-        )
-        .to_go_above_max_line_length();
-    ping();
-}
-"#,
+        indoc! {r#"
+        library;
+
+        fn test() {
+            fuelcoin.really_long_field.other_really_long_field.foo().bar().baz.quux([1,2]).yet_another_call([1, 2, 3, 4, 6, 7, 7, 8, 8, 9, 9, 9, 19, 1123123, 12312, 312, 312, 3123, 12,31, 44],[1,2], true).to_go_above_max_line_length();ping();
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        fn test() {
+            fuelcoin
+                .really_long_field
+                .other_really_long_field
+                .foo()
+                .bar()
+                .baz
+                .quux([1, 2])
+                .yet_another_call(
+                    [
+                        1, 2, 3, 4, 6, 7, 7, 8, 8, 9, 9, 9, 19, 1123123, 12312, 312, 312,
+                        3123, 12, 31, 44,
+                    ],
+                    [1, 2],
+                    true,
+                )
+                .to_go_above_max_line_length();
+            ping();
+        }
+        "#},
     );
 }
 
 #[test]
 fn chained_methods_3() {
     check(
-        r#"
-library;
-
-fn test() {
-    fuelcoin.really_long_field.other_really_long_field.foo().bar().baz.quux([1,2]).yet_another_call(1, 2, 3, 4, 6, 7, 7, 8, 8, 9, 9, 9, 19, 1123123, 12312, 312, 312, 3123, 12,31, 44,[1,2], true).to_go_above_max_line_length();
-}
-        "#,
-        r#"library;
-
-fn test() {
-    fuelcoin
-        .really_long_field
-        .other_really_long_field
-        .foo()
-        .bar()
-        .baz
-        .quux([1, 2])
-        .yet_another_call(
-            1,
-            2,
-            3,
-            4,
-            6,
-            7,
-            7,
-            8,
-            8,
-            9,
-            9,
-            9,
-            19,
-            1123123,
-            12312,
-            312,
-            312,
-            3123,
-            12,
-            31,
-            44,
-            [1, 2],
-            true,
-        )
-        .to_go_above_max_line_length();
-}
-"#,
+        indoc! {r#"
+        library;
+
+        fn test() {
+            fuelcoin.really_long_field.other_really_long_field.foo().bar().baz.quux([1,2]).yet_another_call(1, 2, 3, 4, 6, 7, 7, 8, 8, 9, 9, 9, 19, 1123123, 12312, 312, 312, 3123, 12,31, 44,[1,2], true).to_go_above_max_line_length();
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        fn test() {
+            fuelcoin
+                .really_long_field
+                .other_really_long_field
+                .foo()
+                .bar()
+                .baz
+                .quux([1, 2])
+                .yet_another_call(
+                    1,
+                    2,
+                    3,
+                    4,
+                    6,
+                    7,
+                    7,
+                    8,
+                    8,
+                    9,
+                    9,
+                    9,
+                    19,
+                    1123123,
+                    12312,
+                    312,
+                    312,
+                    3123,
+                    12,
+                    31,
+                    44,
+                    [1, 2],
+                    true,
+                )
+                .to_go_above_max_line_length();
+        }
+        "#},
     );
 }
 
 #[test]
 fn comment_in_the_middle() {
     check(
-        r#"
+        indoc! {r#"
         library;
 
         fn test() {
@@ -1950,132 +2086,139 @@ fn comment_in_the_middle() {
 
 
 
-        }"#,
-        r#"library;
+        }"#},
+        indoc! {r#"
+        library;
 
-fn test() {
-    let number: /* this number is for counting */ u64 = 10;
-}
-"#,
+        fn test() {
+            let number: /* this number is for counting */ u64 = 10;
+        }
+        "#},
     );
 }
 
 #[test]
 fn trait_multiline_method_x() {
     check(
-        r#"library; trait MyComplexTrait { fn complex_function( arg1: MyStruct<[b256; 3], u8>, arg2: [MyStruct<u64, bool>; 4],
-        arg3: (str[5], bool),
-        arg4: MyOtherStruct) -> str[6]; }"#,
-        r#"library;
-trait MyComplexTrait {
-    fn complex_function(
-        arg1: MyStruct<[b256; 3], u8>,
-        arg2: [MyStruct<u64, bool>; 4],
+        indoc! {r#"
+        library; trait MyComplexTrait { fn complex_function( arg1: MyStruct<[b256; 3], u8>, arg2: [MyStruct<u64, bool>; 4],
         arg3: (str[5], bool),
-        arg4: MyOtherStruct,
-    ) -> str[6];
-}
-"#,
+        arg4: MyOtherStruct) -> str[6]; }"#},
+        indoc! {r#"
+        library;
+        trait MyComplexTrait {
+            fn complex_function(
+                arg1: MyStruct<[b256; 3], u8>,
+                arg2: [MyStruct<u64, bool>; 4],
+                arg3: (str[5], bool),
+                arg4: MyOtherStruct,
+            ) -> str[6];
+        }
+        "#},
     );
 }
 
 #[test]
 fn long_array() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
+                fn main() {
+                    let x = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,99,22];
+                }"#},
+        indoc! {r#"
+        library;
         fn main() {
-            let x = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,99,22];
-        }"#,
-        r#"library;
-fn main() {
-    let x = [
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-        22, 99, 22,
-    ];
-}
-"#,
+            let x = [
+                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+                22, 99, 22,
+            ];
+        }
+        "#},
     );
 }
 
 #[test]
 fn struct_new_line() {
     check(
-        r#"
+        indoc! {r#"
         library;
 
-struct Item {
-    price: u64, amount: u64,
-    id: u64,
-}
+        struct Item {
+            price: u64, amount: u64,
+            id: u64,
+        }
 
-enum MyEnum {
-    Item: Item,
-}
+        enum MyEnum {
+            Item: Item,
+        }
 
-fn main() {
-    let my_enum = MyEnum::Item(Item {
-        price: 5, amount: 2, id: 42,
-    });
-    my_enum.test(Item {
-        price: 5, amount: 2, id: 42,
-    });
-}
-            "#,
-        r#"library;
+        fn main() {
+            let my_enum = MyEnum::Item(Item {
+                price: 5, amount: 2, id: 42,
+            });
+            my_enum.test(Item {
+                price: 5, amount: 2, id: 42,
+            });
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-struct Item {
-    price: u64,
-    amount: u64,
-    id: u64,
-}
+        struct Item {
+            price: u64,
+            amount: u64,
+            id: u64,
+        }
 
-enum MyEnum {
-    Item: Item,
-}
+        enum MyEnum {
+            Item: Item,
+        }
 
-fn main() {
-    let my_enum = MyEnum::Item(Item {
-        price: 5,
-        amount: 2,
-        id: 42,
-    });
-    my_enum.test(Item {
-        price: 5,
-        amount: 2,
-        id: 42,
-    });
-}
-"#,
+        fn main() {
+            let my_enum = MyEnum::Item(Item {
+                price: 5,
+                amount: 2,
+                id: 42,
+            });
+            my_enum.test(Item {
+                price: 5,
+                amount: 2,
+                id: 42,
+            });
+        }
+        "#},
     )
 }
 
 #[test]
 fn struct_new_line_2() {
     check(
-        r#"
+        indoc! {r#"
+        library;
+        impl Convert<Square> for Rectangle { fn from(t: Square) -> Self {
+        Self { width: t
+            .width,length: t.width,
+        }}}
+        "#},
+        indoc! {r#"
         library;
-impl Convert<Square> for Rectangle { fn from(t: Square) -> Self {
-Self { width: t
-    .width,length: t.width,
-}}}
-            "#,
-        r#"library;
-impl Convert<Square> for Rectangle {
-    fn from(t: Square) -> Self {
-        Self {
-            width: t.width,
-            length: t.width,
+        impl Convert<Square> for Rectangle {
+            fn from(t: Square) -> Self {
+                Self {
+                    width: t.width,
+                    length: t.width,
+                }
+            }
         }
-    }
-}
-"#,
+        "#},
     )
 }
 
 #[test]
 fn func_call_long_args() {
     check(
-        r#"
+        indoc! {r#"
         library;
 
         fn access_control_with_identity() {
@@ -2084,28 +2227,29 @@ fn func_call_long_args() {
             require(sender == storage.owner.read(), MyError::UnauthorizedUser(sender));
             // ANCHOR_END: access_control_with_identity
         }
-    "#,
-        r#"library;
+        "#},
+        indoc! {r#"
+        library;
 
-fn access_control_with_identity() {
-    // ANCHOR: access_control_with_identity
-    let sender = msg_sender().unwrap();
-    require(
-        sender == storage
-            .owner
-            .read(),
-        MyError::UnauthorizedUser(sender),
-    );
-    // ANCHOR_END: access_control_with_identity
-}
-"#,
+        fn access_control_with_identity() {
+            // ANCHOR: access_control_with_identity
+            let sender = msg_sender().unwrap();
+            require(
+                sender == storage
+                    .owner
+                    .read(),
+                MyError::UnauthorizedUser(sender),
+            );
+            // ANCHOR_END: access_control_with_identity
+        }
+        "#},
     )
 }
 
 #[test]
 fn func_call_long_args_with_long_expr() {
     check(
-        r#"
+        indoc! {r#"
         library;
 
         fn access_control_with_identity() {
@@ -2114,31 +2258,32 @@ fn func_call_long_args_with_long_expr() {
             require(sender == storage.owner.read().some_prop().that_is_too_long_to_fit_in_one_line().or_two_lines(), MyError::UnauthorizedUser(sender));
             // ANCHOR_END: access_control_with_identity
         }
-    "#,
-        r#"library;
+        "#},
+        indoc! {r#"
+        library;
 
-fn access_control_with_identity() {
-    // ANCHOR: access_control_with_identity
-    let sender = msg_sender().unwrap();
-    require(
-        sender == storage
-            .owner
-            .read()
-            .some_prop()
-            .that_is_too_long_to_fit_in_one_line()
-            .or_two_lines(),
-        MyError::UnauthorizedUser(sender),
-    );
-    // ANCHOR_END: access_control_with_identity
-}
-"#,
+        fn access_control_with_identity() {
+            // ANCHOR: access_control_with_identity
+            let sender = msg_sender().unwrap();
+            require(
+                sender == storage
+                    .owner
+                    .read()
+                    .some_prop()
+                    .that_is_too_long_to_fit_in_one_line()
+                    .or_two_lines(),
+                MyError::UnauthorizedUser(sender),
+            );
+            // ANCHOR_END: access_control_with_identity
+        }
+        "#},
     )
 }
 
 #[test]
 fn method_call_long_args_with_long_expr() {
     check(
-        r#"
+        indoc! {r#"
         library;
 
         fn access_control_with_identity() {
@@ -2147,782 +2292,828 @@ fn method_call_long_args_with_long_expr() {
             sender.require(sender == storage.owner.read().some_prop().that_is_too_long_to_fit_in_one_line().or_two_lines(), MyError::UnauthorizedUser(sender));
             // ANCHOR_END: access_control_with_identity
         }
-    "#,
-        r#"library;
+        "#},
+        indoc! {r#"
+        library;
 
-fn access_control_with_identity() {
-    // ANCHOR: access_control_with_identity
-    let sender = msg_sender().unwrap();
-    sender.require(
-        sender == storage
-            .owner
-            .read()
-            .some_prop()
-            .that_is_too_long_to_fit_in_one_line()
-            .or_two_lines(),
-        MyError::UnauthorizedUser(sender),
-    );
-    // ANCHOR_END: access_control_with_identity
-}
-"#,
+        fn access_control_with_identity() {
+            // ANCHOR: access_control_with_identity
+            let sender = msg_sender().unwrap();
+            sender.require(
+                sender == storage
+                    .owner
+                    .read()
+                    .some_prop()
+                    .that_is_too_long_to_fit_in_one_line()
+                    .or_two_lines(),
+                MyError::UnauthorizedUser(sender),
+            );
+            // ANCHOR_END: access_control_with_identity
+        }
+        "#},
     )
 }
 
 #[test]
 fn while_too_long_expr() {
     check(
-        r#"
-    library;
-
-    fn main() {
-    // ANCHOR_END: vec_get
-    // ANCHOR: vec_get_oob
-    let does_not_exist = v.get(100);
-    // ...decide here how to handle an out-of-bounds access
-    // ANCHOR_END: vec_get_oob
-    // ANCHOR: vec_iterate
-    let mut i = 0;
-    while i < v.len() {
-        log(v.get(i).unwrap());
-        i += 1;
-    }
-    // ANCHOR_END: vec_iterate
-    // ANCHOR: vec_multiple_data_types
-    enum TableCell {
-        Int: u64,
-        B256: b256,
-        Boolean: bool,
-    }
-}
-"#,
-        r#"library;
-
-fn main() {
-    // ANCHOR_END: vec_get
-    // ANCHOR: vec_get_oob
-    let does_not_exist = v.get(100);
-    // ...decide here how to handle an out-of-bounds access
-    // ANCHOR_END: vec_get_oob
-    // ANCHOR: vec_iterate
-    let mut i = 0;
-    while i < v.len() {
-        log(v.get(i).unwrap());
-        i += 1;
-    }
-    // ANCHOR_END: vec_iterate
-    // ANCHOR: vec_multiple_data_types
-    enum TableCell {
-        Int: u64,
-        B256: b256,
-        Boolean: bool,
-    }
-}
-"#,
+        indoc! {r#"
+        library;
+
+        fn main() {
+        // ANCHOR_END: vec_get
+        // ANCHOR: vec_get_oob
+        let does_not_exist = v.get(100);
+        // ...decide here how to handle an out-of-bounds access
+        // ANCHOR_END: vec_get_oob
+        // ANCHOR: vec_iterate
+        let mut i = 0;
+        while i < v.len() {
+            log(v.get(i).unwrap());
+            i += 1;
+        }
+        // ANCHOR_END: vec_iterate
+        // ANCHOR: vec_multiple_data_types
+        enum TableCell {
+            Int: u64,
+            B256: b256,
+            Boolean: bool,
+        }
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        fn main() {
+            // ANCHOR_END: vec_get
+            // ANCHOR: vec_get_oob
+            let does_not_exist = v.get(100);
+            // ...decide here how to handle an out-of-bounds access
+            // ANCHOR_END: vec_get_oob
+            // ANCHOR: vec_iterate
+            let mut i = 0;
+            while i < v.len() {
+                log(v.get(i).unwrap());
+                i += 1;
+            }
+            // ANCHOR_END: vec_iterate
+            // ANCHOR: vec_multiple_data_types
+            enum TableCell {
+                Int: u64,
+                B256: b256,
+                Boolean: bool,
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn match_as_arg() {
     check(
-        r#"
-    library;
-
-    fn main() {
-         assert(match color { Color::Blue => true,
-    _ => false,
-    });
-}
-"#,
-        r#"library;
+        indoc! {r#"
+        library;
 
-fn main() {
-    assert(match color {
-        Color::Blue => true,
+        fn main() {
+             assert(match color { Color::Blue => true,
         _ => false,
-    });
-}
-"#,
+        });
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        fn main() {
+            assert(match color {
+                Color::Blue => true,
+                _ => false,
+            });
+        }
+        "#},
     );
 }
 
 #[test]
 fn single_long_arg() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-    fn main() {
-        if foo {
-            // ANCHOR: storage_map_insert
-                let addr1 = Address::from(0x010101010101010101010101010101010101010101010101010101010101010101010101010101);
-            }
-    }
-    "#,
-        r#"library;
+        fn main() {
+            if foo {
+                // ANCHOR: storage_map_insert
+                    let addr1 = Address::from(0x010101010101010101010101010101010101010101010101010101010101010101010101010101);
+                }
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn main() {
-    if foo {
-        // ANCHOR: storage_map_insert
-        let addr1 = Address::from(
-            0x010101010101010101010101010101010101010101010101010101010101010101010101010101,
-        );
-    }
-}
-"#,
+        fn main() {
+            if foo {
+                // ANCHOR: storage_map_insert
+                let addr1 = Address::from(
+                    0x010101010101010101010101010101010101010101010101010101010101010101010101010101,
+                );
+            }
+        }
+        "#},
     );
 }
 
 #[test]
 fn method_call_2() {
     check(
-        r#"
-    library;
-
-fn main() {
-    let contract_address = 0x9299da6c73e6dc03eeabcce242bb347de3f5f56cd1c70926d76526d7ed199b8b;
-    let caller = abi(Wallet, contract_address);
-    let amount_to_send = 200;
-    let recipient_address = Address::from(contract_address);
-    caller.send_funds { gas: 10000, coins: 0, asset_id: ZERO_B256 }(
-            amount_to_send,
-            recipient_address,
-        );
-}
-
-    "#,
-        r#"library;
-
-fn main() {
-    let contract_address = 0x9299da6c73e6dc03eeabcce242bb347de3f5f56cd1c70926d76526d7ed199b8b;
-    let caller = abi(Wallet, contract_address);
-    let amount_to_send = 200;
-    let recipient_address = Address::from(contract_address);
-    caller
-        .send_funds {
-            gas: 10000,
-            coins: 0,
-            asset_id: ZERO_B256,
-        }(amount_to_send, recipient_address);
-}
-"#,
+        indoc! {r#"
+        library;
+
+        fn main() {
+            let contract_address = 0x9299da6c73e6dc03eeabcce242bb347de3f5f56cd1c70926d76526d7ed199b8b;
+            let caller = abi(Wallet, contract_address);
+            let amount_to_send = 200;
+            let recipient_address = Address::from(contract_address);
+            caller.send_funds { gas: 10000, coins: 0, asset_id: ZERO_B256 }(
+                    amount_to_send,
+                    recipient_address,
+                );
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        fn main() {
+            let contract_address = 0x9299da6c73e6dc03eeabcce242bb347de3f5f56cd1c70926d76526d7ed199b8b;
+            let caller = abi(Wallet, contract_address);
+            let amount_to_send = 200;
+            let recipient_address = Address::from(contract_address);
+            caller
+                .send_funds {
+                    gas: 10000,
+                    coins: 0,
+                    asset_id: ZERO_B256,
+                }(amount_to_send, recipient_address);
+        }
+        "#},
     )
 }
 
 #[test]
 fn method_call_3() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-fn enum_in_vec() -> Vec<Pasta> {
-   let mut vec: Vec<Pasta> = Vec::new();
-   vec.push(Pasta::Tortelini(Bimba {
-      bim: 1111,
-      bam: 2222_u32,
-   }));
-   vec.push(Pasta::Rigatoni(1987));
-   vec.push(Pasta::Spaghetti(true));
-   vec
-}
-       "#,
-        r#"library;
+        fn enum_in_vec() -> Vec<Pasta> {
+           let mut vec: Vec<Pasta> = Vec::new();
+           vec.push(Pasta::Tortelini(Bimba {
+              bim: 1111,
+              bam: 2222_u32,
+           }));
+           vec.push(Pasta::Rigatoni(1987));
+           vec.push(Pasta::Spaghetti(true));
+           vec
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn enum_in_vec() -> Vec<Pasta> {
-    let mut vec: Vec<Pasta> = Vec::new();
-    vec.push(Pasta::Tortelini(Bimba {
-        bim: 1111,
-        bam: 2222_u32,
-    }));
-    vec.push(Pasta::Rigatoni(1987));
-    vec.push(Pasta::Spaghetti(true));
-    vec
-}
-"#,
+        fn enum_in_vec() -> Vec<Pasta> {
+            let mut vec: Vec<Pasta> = Vec::new();
+            vec.push(Pasta::Tortelini(Bimba {
+                bim: 1111,
+                bam: 2222_u32,
+            }));
+            vec.push(Pasta::Rigatoni(1987));
+            vec.push(Pasta::Spaghetti(true));
+            vec
+        }
+        "#},
     );
 }
 
 #[test]
 fn test_comment_random_places() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-fn enum_in_vec() -> Vec<Pasta> {
-    let number: /*
-        this number is for counting
-    */ u64 = 10;
-    let number: // this number is for counting
-    u64 = 10;
-}
-    "#,
-        r#"library;
+        fn enum_in_vec() -> Vec<Pasta> {
+            let number: /*
+                this number is for counting
+            */ u64 = 10;
+            let number: // this number is for counting
+            u64 = 10;
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn enum_in_vec() -> Vec<Pasta> {
-    let number: /*
-        this number is for counting
-    */ u64 = 10;
-    let number: // this number is for counting
- u64 = 10;
-}
-"#,
+        fn enum_in_vec() -> Vec<Pasta> {
+            let number: /*
+                this number is for counting
+            */ u64 = 10;
+            let number: // this number is for counting
+         u64 = 10;
+        }
+        "#},
     );
 }
 
 #[test]
 fn test_comment_v2() {
     check(
-        r#"library;
-    /// This is documentation for a commented out function
-    // fn commented_out_function() {
-    //}
-        
-    fn test_function() -> bool {
-        true
-    }
-        "#,
-        r#"library;
-/// This is documentation for a commented out function
-// fn commented_out_function() {
-//}
+        indoc! {r#"
+        library;
+            /// This is documentation for a commented out function
+            // fn commented_out_function() {
+            //}
+                
+            fn test_function() -> bool {
+                true
+            }
+        "#},
+        indoc! {r#"
+        library;
+        /// This is documentation for a commented out function
+        // fn commented_out_function() {
+        //}
 
-fn test_function() -> bool {
-    true
-}
-"#,
+        fn test_function() -> bool {
+            true
+        }
+        "#},
     );
 }
 
 #[test]
 fn long_doc_break_new_line() {
     check(
-        r#"library;
-
-/// Allocates zeroed memory on the heap.
-///
-/// # Additional Information
-///
-/// In the FuelVM, the heap begins at `VM_MAX_RAM` and grows downward.
-/// The heap pointer(`$hp`) always points to the first allocated byte.
-///
-/// Initially the heap will look like this:
-/// ```
-///                                                     ▾$hp
-/// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
-///                                                     ▴VM_MAX_RAM
-/// ```
-/// After allocating with `let ptr = alloc::<u64>(1)`:
-/// ```
-///                             ▾$hp
-/// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
-///                             ▴ptr                    ▴VM_MAX_RAM
-/// ```
-/// After writing with `sw(ptr, u64::max())`:
-/// ```
-///                             ▾$hp
-/// ... 00 00 00 00 00 00 00 00 FF FF FF FF FF FF FF FF |
-///                             ▴ptr                    ▴VM_MAX_RAM
-/// ```
-/// For more information, see the Fuel Spec for [VM Initialization](https://fuellabs.github.io/fuel-specs/master/vm#vm-initialization)
-/// and the VM Instruction Set for [Memory Allocation](https://docs.fuel.network/docs/specs/fuel-vm/instruction-set#aloc-allocate-memory).
-///
-/// # Arguments
-/// 
-/// * `count`: [u64] - The number of `size_of<T>` bytes to allocate onto the heap.
-///
-/// # Returns
-///
-/// * [raw_ptr] - The pointer to the newly allocated memory.
-///
-/// # Examples
-///
-/// ```sway
-/// use std::alloc::alloc;
-/// 
-/// fn foo() {
-///     let ptr = alloc::<u64>(2);
-///     assert(!ptr.is_null());
-/// }
-/// ```
-/// Reallocates the given area of memory.
-/// 
-/// # Arguments
-///
-/// * `ptr`: [raw_ptr] - The pointer to the area of memory to reallocate.
-/// * `count`: [u64] - The number of `size_of<T>` bytes kept when reallocating. These are not set to 0.
-/// * `new_count`: [u64] - The number of new `size_of<T>` bytes to allocate. These are set to 0.
-///
-/// # Returns
-/// 
-/// * [raw_ptr] - The pointer to the newly reallocated memory.
-///
-/// # Examples
-///
-/// ```sway
-/// use std::alloc::{alloc, realloc};
-///
-/// fn foo() {
-///     let ptr = alloc::<u64>(1);
-///     ptr.write(5);
-///     let reallocated_ptr = realloc::<u64>(ptr, 1, 2);
-///     assert(reallocated_ptr.read::<u64>() == 5);
-/// }
-/// ```
-pub fn realloc<T>(ptr: raw_ptr, count: u64, new_count: u64) -> raw_ptr {
-    if new_count > count {
-        let new_ptr = alloc::<T>(new_count);
-        if count > 0 {
-            ptr.copy_to::<T>(new_ptr, count);
-        }
-        new_ptr
-    } else {
-        ptr
-    }
-}
-
-/// Allocates zeroed memory on the heap in individual bytes.
-pub fn alloc_bytes(count: u64) -> raw_ptr {
-    asm(size: count, ptr) {
-        aloc size;
-        move ptr hp;
-        ptr: raw_ptr
-    }
-}
-
-        "#,
-        r#"library;
-
-/// Allocates zeroed memory on the heap.
-///
-/// # Additional Information
-///
-/// In the FuelVM, the heap begins at `VM_MAX_RAM` and grows downward.
-/// The heap pointer(`$hp`) always points to the first allocated byte.
-///
-/// Initially the heap will look like this:
-/// ```
-///                                                     ▾$hp
-/// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
-///                                                     ▴VM_MAX_RAM
-/// ```
-/// After allocating with `let ptr = alloc::<u64>(1)`:
-/// ```
-///                             ▾$hp
-/// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
-///                             ▴ptr                    ▴VM_MAX_RAM
-/// ```
-/// After writing with `sw(ptr, u64::max())`:
-/// ```
-///                             ▾$hp
-/// ... 00 00 00 00 00 00 00 00 FF FF FF FF FF FF FF FF |
-///                             ▴ptr                    ▴VM_MAX_RAM
-/// ```
-/// For more information, see the Fuel Spec for [VM Initialization](https://fuellabs.github.io/fuel-specs/master/vm#vm-initialization)
-/// and the VM Instruction Set for [Memory Allocation](https://docs.fuel.network/docs/specs/fuel-vm/instruction-set#aloc-allocate-memory).
-///
-/// # Arguments
-///
-/// * `count`: [u64] - The number of `size_of<T>` bytes to allocate onto the heap.
-///
-/// # Returns
-///
-/// * [raw_ptr] - The pointer to the newly allocated memory.
-///
-/// # Examples
-///
-/// ```sway
-/// use std::alloc::alloc;
-///
-/// fn foo() {
-///     let ptr = alloc::<u64>(2);
-///     assert(!ptr.is_null());
-/// }
-/// ```
-/// Reallocates the given area of memory.
-///
-/// # Arguments
-///
-/// * `ptr`: [raw_ptr] - The pointer to the area of memory to reallocate.
-/// * `count`: [u64] - The number of `size_of<T>` bytes kept when reallocating. These are not set to 0.
-/// * `new_count`: [u64] - The number of new `size_of<T>` bytes to allocate. These are set to 0.
-///
-/// # Returns
-///
-/// * [raw_ptr] - The pointer to the newly reallocated memory.
-///
-/// # Examples
-///
-/// ```sway
-/// use std::alloc::{alloc, realloc};
-///
-/// fn foo() {
-///     let ptr = alloc::<u64>(1);
-///     ptr.write(5);
-///     let reallocated_ptr = realloc::<u64>(ptr, 1, 2);
-///     assert(reallocated_ptr.read::<u64>() == 5);
-/// }
-/// ```
-pub fn realloc<T>(ptr: raw_ptr, count: u64, new_count: u64) -> raw_ptr {
-    if new_count > count {
-        let new_ptr = alloc::<T>(new_count);
-        if count > 0 {
-            ptr.copy_to::<T>(new_ptr, count);
-        }
-        new_ptr
-    } else {
-        ptr
-    }
-}
-
-/// Allocates zeroed memory on the heap in individual bytes.
-pub fn alloc_bytes(count: u64) -> raw_ptr {
-    asm(size: count, ptr) {
-        aloc size;
-        move ptr hp;
-        ptr: raw_ptr
-    }
-}
-"#,
+        indoc! {r#"
+        library;
+
+        /// Allocates zeroed memory on the heap.
+        ///
+        /// # Additional Information
+        ///
+        /// In the FuelVM, the heap begins at `VM_MAX_RAM` and grows downward.
+        /// The heap pointer(`$hp`) always points to the first allocated byte.
+        ///
+        /// Initially the heap will look like this:
+        /// ```
+        ///                                                     ▾$hp
+        /// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
+        ///                                                     ▴VM_MAX_RAM
+        /// ```
+        /// After allocating with `let ptr = alloc::<u64>(1)`:
+        /// ```
+        ///                             ▾$hp
+        /// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
+        ///                             ▴ptr                    ▴VM_MAX_RAM
+        /// ```
+        /// After writing with `sw(ptr, u64::max())`:
+        /// ```
+        ///                             ▾$hp
+        /// ... 00 00 00 00 00 00 00 00 FF FF FF FF FF FF FF FF |
+        ///                             ▴ptr                    ▴VM_MAX_RAM
+        /// ```
+        /// For more information, see the Fuel Spec for [VM Initialization](https://fuellabs.github.io/fuel-specs/master/vm#vm-initialization)
+        /// and the VM Instruction Set for [Memory Allocation](https://docs.fuel.network/docs/specs/fuel-vm/instruction-set#aloc-allocate-memory).
+        ///
+        /// # Arguments
+        /// 
+        /// * `count`: [u64] - The number of `size_of<T>` bytes to allocate onto the heap.
+        ///
+        /// # Returns
+        ///
+        /// * [raw_ptr] - The pointer to the newly allocated memory.
+        ///
+        /// # Examples
+        ///
+        /// ```sway
+        /// use std::alloc::alloc;
+        /// 
+        /// fn foo() {
+        ///     let ptr = alloc::<u64>(2);
+        ///     assert(!ptr.is_null());
+        /// }
+        /// ```
+        /// Reallocates the given area of memory.
+        /// 
+        /// # Arguments
+        ///
+        /// * `ptr`: [raw_ptr] - The pointer to the area of memory to reallocate.
+        /// * `count`: [u64] - The number of `size_of<T>` bytes kept when reallocating. These are not set to 0.
+        /// * `new_count`: [u64] - The number of new `size_of<T>` bytes to allocate. These are set to 0.
+        ///
+        /// # Returns
+        /// 
+        /// * [raw_ptr] - The pointer to the newly reallocated memory.
+        ///
+        /// # Examples
+        ///
+        /// ```sway
+        /// use std::alloc::{alloc, realloc};
+        ///
+        /// fn foo() {
+        ///     let ptr = alloc::<u64>(1);
+        ///     ptr.write(5);
+        ///     let reallocated_ptr = realloc::<u64>(ptr, 1, 2);
+        ///     assert(reallocated_ptr.read::<u64>() == 5);
+        /// }
+        /// ```
+        pub fn realloc<T>(ptr: raw_ptr, count: u64, new_count: u64) -> raw_ptr {
+            if new_count > count {
+                let new_ptr = alloc::<T>(new_count);
+                if count > 0 {
+                    ptr.copy_to::<T>(new_ptr, count);
+                }
+                new_ptr
+            } else {
+                ptr
+            }
+        }
+
+        /// Allocates zeroed memory on the heap in individual bytes.
+        pub fn alloc_bytes(count: u64) -> raw_ptr {
+            asm(size: count, ptr) {
+                aloc size;
+                move ptr hp;
+                ptr: raw_ptr
+            }
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        /// Allocates zeroed memory on the heap.
+        ///
+        /// # Additional Information
+        ///
+        /// In the FuelVM, the heap begins at `VM_MAX_RAM` and grows downward.
+        /// The heap pointer(`$hp`) always points to the first allocated byte.
+        ///
+        /// Initially the heap will look like this:
+        /// ```
+        ///                                                     ▾$hp
+        /// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
+        ///                                                     ▴VM_MAX_RAM
+        /// ```
+        /// After allocating with `let ptr = alloc::<u64>(1)`:
+        /// ```
+        ///                             ▾$hp
+        /// ... 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
+        ///                             ▴ptr                    ▴VM_MAX_RAM
+        /// ```
+        /// After writing with `sw(ptr, u64::max())`:
+        /// ```
+        ///                             ▾$hp
+        /// ... 00 00 00 00 00 00 00 00 FF FF FF FF FF FF FF FF |
+        ///                             ▴ptr                    ▴VM_MAX_RAM
+        /// ```
+        /// For more information, see the Fuel Spec for [VM Initialization](https://fuellabs.github.io/fuel-specs/master/vm#vm-initialization)
+        /// and the VM Instruction Set for [Memory Allocation](https://docs.fuel.network/docs/specs/fuel-vm/instruction-set#aloc-allocate-memory).
+        ///
+        /// # Arguments
+        ///
+        /// * `count`: [u64] - The number of `size_of<T>` bytes to allocate onto the heap.
+        ///
+        /// # Returns
+        ///
+        /// * [raw_ptr] - The pointer to the newly allocated memory.
+        ///
+        /// # Examples
+        ///
+        /// ```sway
+        /// use std::alloc::alloc;
+        ///
+        /// fn foo() {
+        ///     let ptr = alloc::<u64>(2);
+        ///     assert(!ptr.is_null());
+        /// }
+        /// ```
+        /// Reallocates the given area of memory.
+        ///
+        /// # Arguments
+        ///
+        /// * `ptr`: [raw_ptr] - The pointer to the area of memory to reallocate.
+        /// * `count`: [u64] - The number of `size_of<T>` bytes kept when reallocating. These are not set to 0.
+        /// * `new_count`: [u64] - The number of new `size_of<T>` bytes to allocate. These are set to 0.
+        ///
+        /// # Returns
+        ///
+        /// * [raw_ptr] - The pointer to the newly reallocated memory.
+        ///
+        /// # Examples
+        ///
+        /// ```sway
+        /// use std::alloc::{alloc, realloc};
+        ///
+        /// fn foo() {
+        ///     let ptr = alloc::<u64>(1);
+        ///     ptr.write(5);
+        ///     let reallocated_ptr = realloc::<u64>(ptr, 1, 2);
+        ///     assert(reallocated_ptr.read::<u64>() == 5);
+        /// }
+        /// ```
+        pub fn realloc<T>(ptr: raw_ptr, count: u64, new_count: u64) -> raw_ptr {
+            if new_count > count {
+                let new_ptr = alloc::<T>(new_count);
+                if count > 0 {
+                    ptr.copy_to::<T>(new_ptr, count);
+                }
+                new_ptr
+            } else {
+                ptr
+            }
+        }
+
+        /// Allocates zeroed memory on the heap in individual bytes.
+        pub fn alloc_bytes(count: u64) -> raw_ptr {
+            asm(size: count, ptr) {
+                aloc size;
+                move ptr hp;
+                ptr: raw_ptr
+            }
+        }
+        "#},
     )
 }
 
 #[test]
 fn broken_doc_comment() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
+                /// line 1
+                /// line 2
+                // line 3
+                /// line 4
+                // line 5
+                /// line 6
+                fn test() {
+                }
+        "#},
+        indoc! {r#"
+        library;
         /// line 1
         /// line 2
         // line 3
         /// line 4
         // line 5
         /// line 6
-        fn test() {
-        }
-    "#,
-        r#"library;
-/// line 1
-/// line 2
-// line 3
-/// line 4
-// line 5
-/// line 6
-fn test() {}
-"#,
+        fn test() {}
+        "#},
     );
 }
 
 #[test]
 fn asm_block_v2() {
     check(
-        r#"library;
-    
-    pub fn transfer(self, asset_id: AssetId, amount: u64) {
-        // maintain a manual index as we only have `while` loops in sway atm:
-        let mut index = 0;
-
-        asm(input: input) {
-            input: u256
-        }
-
-        // If an output of type `OutputVariable` is found, check if its `amount` is
-        // zero. As one cannot transfer zero coins to an output without a panic, a
-        // variable output with a value of zero is by definition unused.
-        let number_of_outputs = output_count();
-        while index < number_of_outputs {
-            if let Output::Variable = output_type(index) {
-                if output_amount(index) == 0 {
-                    asm(r1: self.value, r2: index, r3: amount, r4: asset_id.value.with_long_long_name) {
-                        tro r1 r2 r3 r4;
-                    };
-                    return;
-                }
+        indoc! {r#"
+        library;
+        
+        pub fn transfer(self, asset_id: AssetId, amount: u64) {
+            // maintain a manual index as we only have `while` loops in sway atm:
+            let mut index = 0;
+
+            asm(input: input) {
+                input: u256
             }
-            index += 1;
-        }
-
-        revert(FAILED_TRANSFER_TO_ADDRESS_SIGNAL);
-    }
-    "#,
-        r#"library;
-
-pub fn transfer(self, asset_id: AssetId, amount: u64) {
-    // maintain a manual index as we only have `while` loops in sway atm:
-    let mut index = 0;
-
-    asm(input: input) {
-        input: u256
-    }
-
-    // If an output of type `OutputVariable` is found, check if its `amount` is
-    // zero. As one cannot transfer zero coins to an output without a panic, a
-    // variable output with a value of zero is by definition unused.
-    let number_of_outputs = output_count();
-    while index < number_of_outputs {
-        if let Output::Variable = output_type(index) {
-            if output_amount(index) == 0 {
-                asm(
-                    r1: self.value,
-                    r2: index,
-                    r3: amount,
-                    r4: asset_id.value.with_long_long_name,
-                ) {
-                    tro r1 r2 r3 r4;
-                };
-                return;
+
+            // If an output of type `OutputVariable` is found, check if its `amount` is
+            // zero. As one cannot transfer zero coins to an output without a panic, a
+            // variable output with a value of zero is by definition unused.
+            let number_of_outputs = output_count();
+            while index < number_of_outputs {
+                if let Output::Variable = output_type(index) {
+                    if output_amount(index) == 0 {
+                        asm(r1: self.value, r2: index, r3: amount, r4: asset_id.value.with_long_long_name) {
+                            tro r1 r2 r3 r4;
+                        };
+                        return;
+                    }
+                }
+                index += 1;
             }
+
+            revert(FAILED_TRANSFER_TO_ADDRESS_SIGNAL);
         }
-        index += 1;
-    }
+        "#},
+        indoc! {r#"
+        library;
 
-    revert(FAILED_TRANSFER_TO_ADDRESS_SIGNAL);
-}
-"#,
+        pub fn transfer(self, asset_id: AssetId, amount: u64) {
+            // maintain a manual index as we only have `while` loops in sway atm:
+            let mut index = 0;
+
+            asm(input: input) {
+                input: u256
+            }
+
+            // If an output of type `OutputVariable` is found, check if its `amount` is
+            // zero. As one cannot transfer zero coins to an output without a panic, a
+            // variable output with a value of zero is by definition unused.
+            let number_of_outputs = output_count();
+            while index < number_of_outputs {
+                if let Output::Variable = output_type(index) {
+                    if output_amount(index) == 0 {
+                        asm(
+                            r1: self.value,
+                            r2: index,
+                            r3: amount,
+                            r4: asset_id.value.with_long_long_name,
+                        ) {
+                            tro r1 r2 r3 r4;
+                        };
+                        return;
+                    }
+                }
+                index += 1;
+            }
+
+            revert(FAILED_TRANSFER_TO_ADDRESS_SIGNAL);
+        }
+        "#},
     );
 }
 
 #[test]
 fn long_expr_assign() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-fn foo() {
-    let x = self.a > other.a || (self.a == other.a && (self.b > other.b || (self.b == other.b && (self.c > other.c || (self.c == other.c && self.d > other.d)))));
-}
-    "#,
-        r#"library;
+        fn foo() {
+            let x = self.a > other.a || (self.a == other.a && (self.b > other.b || (self.b == other.b && (self.c > other.c || (self.c == other.c && self.d > other.d)))));
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn foo() {
-    let x = self.a > other.a
-        || (self.a == other.a
-            && (self.b > other.b
-                || (self.b == other.b
-                    && (self.c > other.c
-                        || (self.c == other.c
-                            && self.d > other.d)))));
-}
-"#,
+        fn foo() {
+            let x = self.a > other.a
+                || (self.a == other.a
+                    && (self.b > other.b
+                        || (self.b == other.b
+                            && (self.c > other.c
+                                || (self.c == other.c
+                                    && self.d > other.d)))));
+        }
+        "#},
     );
 }
 
 #[test]
 fn long_expr_return() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
 
-fn foo() {
-    self.a > other.a || (self.a == other.a && (self.b > other.b || (self.b == other.b && (self.c > other.c || (self.c == other.c && self.d > other.d)))));
-}
-    "#,
-        r#"library;
+        fn foo() {
+            self.a > other.a || (self.a == other.a && (self.b > other.b || (self.b == other.b && (self.c > other.c || (self.c == other.c && self.d > other.d)))));
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-fn foo() {
-    self.a > other.a
-        || (self.a == other.a
-            && (self.b > other.b
-                || (self.b == other.b
-                    && (self.c > other.c
-                        || (self.c == other.c
-                            && self.d > other.d)))));
-}
-"#,
+        fn foo() {
+            self.a > other.a
+                || (self.a == other.a
+                    && (self.b > other.b
+                        || (self.b == other.b
+                            && (self.c > other.c
+                                || (self.c == other.c
+                                    && self.d > other.d)))));
+        }
+        "#},
     );
 }
 
 #[test]
 fn long_expr_single_arg() {
     check(
-        r#"library;
-fn test() {
-    Self::from((
-        self.b * other.c + result_b_d.upper + overflow_of_b_to_a_3 + overflow_of_b_to_a_2 + overflow_of_b_to_a_1 + overflow_of_b_to_a_0,
-        b,
-        c,
-        result_d_d.lower,
-    ))
-}
-    "#,
-        r#"library;
-fn test() {
-    Self::from((
-        self.b * other.c + result_b_d.upper + overflow_of_b_to_a_3 + overflow_of_b_to_a_2 + overflow_of_b_to_a_1 + overflow_of_b_to_a_0,
-        b,
-        c,
-        result_d_d.lower,
-    ))
-}
-"#,
+        indoc! {r#"
+        library;
+        fn test() {
+            Self::from((
+                self.b * other.c + result_b_d.upper + overflow_of_b_to_a_3 + overflow_of_b_to_a_2 + overflow_of_b_to_a_1 + overflow_of_b_to_a_0,
+                b,
+                c,
+                result_d_d.lower,
+            ))
+        }
+        "#},
+        indoc! {r#"
+        library;
+        fn test() {
+            Self::from((
+                self.b * other.c + result_b_d.upper + overflow_of_b_to_a_3 + overflow_of_b_to_a_2 + overflow_of_b_to_a_1 + overflow_of_b_to_a_0,
+                b,
+                c,
+                result_d_d.lower,
+            ))
+        }
+        "#},
     );
 }
 
 #[test]
 fn single_argument_not() {
     check(
-        r#"library;
-fn test() {
-    assert(!(U256::from((0, 0, 0, 1)) > U256::from((0, u64::max(), 0, 0))));
-}
-    "#,
-        r#"library;
-fn test() {
-    assert(!(U256::from((0, 0, 0, 1)) > U256::from((0, u64::max(), 0, 0))));
-}
-"#,
+        indoc! {r#"
+        library;
+        fn test() {
+            assert(!(U256::from((0, 0, 0, 1)) > U256::from((0, u64::max(), 0, 0))));
+        }
+        "#},
+        indoc! {r#"
+        library;
+        fn test() {
+            assert(!(U256::from((0, 0, 0, 1)) > U256::from((0, u64::max(), 0, 0))));
+        }
+        "#},
     );
 }
 
 #[test]
 fn use_sorting_items() {
     check(
-        r#"library;
-    
-    use ::option::Option::{*, self, z, foo, bar};
-"#,
-        r#"library;
+        indoc! {r#"
+        library;
+        
+        use ::option::Option::{*, self, z, foo, bar};
+        "#},
+        indoc! {r#"
+        library;
 
-use ::option::Option::{self, bar, foo, z, *};
-"#,
+        use ::option::Option::{self, bar, foo, z, *};
+        "#},
     );
 }
 
 #[test]
 fn whitespace_after_doccomment() {
     check(
-        r#"library;
-    
-/// Trait to evaluate if one value is greater than or equal, or less than or equal to another of the same type.
-trait OrdEq: Ord + Eq {
-} {
-    /// Evaluates if one value of the same type is greater or equal to than another.
-    ///
-    /// # Additional Information
-    ///
-    /// This trait requires that the `Ord` and `Eq` traits are implemented.
-    ///
-    /// # Arguments
-    ///
-    /// * `other`: [Self] - The value of the same type.
-    ///
-    /// # Returns
-    ///
-    /// * [bool] - `true` if `self` is greater than or equal to `other`, otherwise `false`.
-    ///
-    /// # Examples
-    ///
-    /// ```sway
-    /// struct MyStruct {
-    ///     val: u64,
-    /// }
-    ///
-    /// impl Eq for MyStruct {
-    ///     fn eq(self, other: Self) -> bool {
-    ///         self.val == other.val
-    ///     }
-    /// }
-    ///
-    /// impl Ord for MyStruct {
-    ///     fn gt(self, other: Self) -> bool {
-    ///         self.val > other.val
-    ///     }
-    /// }
-    ///
-    /// impl OrdEq for MyStruct {}
-    ///
-    /// fn foo() {
-    ///     let struct1 = MyStruct { val: 10 };
-    ///     let struct2 = MyStruct { val: 10 };
-    ///     let result = struct1 >= struct2;
-    ///     assert(result);
-    /// }
-    /// ```
-    fn ge(self, other: Self) -> bool {
-        self.gt(other) || self.eq(other)
-    }
-    /// Some test
-    fn test() {
-
-    }
-}
-    "#,
-        r#"library;
-
-/// Trait to evaluate if one value is greater than or equal, or less than or equal to another of the same type.
-trait OrdEq: Ord + Eq {
-} {
-    /// Evaluates if one value of the same type is greater or equal to than another.
-    ///
-    /// # Additional Information
-    ///
-    /// This trait requires that the `Ord` and `Eq` traits are implemented.
-    ///
-    /// # Arguments
-    ///
-    /// * `other`: [Self] - The value of the same type.
-    ///
-    /// # Returns
-    ///
-    /// * [bool] - `true` if `self` is greater than or equal to `other`, otherwise `false`.
-    ///
-    /// # Examples
-    ///
-    /// ```sway
-    /// struct MyStruct {
-    ///     val: u64,
-    /// }
-    ///
-    /// impl Eq for MyStruct {
-    ///     fn eq(self, other: Self) -> bool {
-    ///         self.val == other.val
-    ///     }
-    /// }
-    ///
-    /// impl Ord for MyStruct {
-    ///     fn gt(self, other: Self) -> bool {
-    ///         self.val > other.val
-    ///     }
-    /// }
-    ///
-    /// impl OrdEq for MyStruct {}
-    ///
-    /// fn foo() {
-    ///     let struct1 = MyStruct { val: 10 };
-    ///     let struct2 = MyStruct { val: 10 };
-    ///     let result = struct1 >= struct2;
-    ///     assert(result);
-    /// }
-    /// ```
-    fn ge(self, other: Self) -> bool {
-        self.gt(other) || self.eq(other)
-    }
-    /// Some test
-    fn test() {}
-}
-"#,
+        indoc! {r#"
+        library;
+        
+        /// Trait to evaluate if one value is greater than or equal, or less than or equal to another of the same type.
+        trait OrdEq: Ord + Eq {
+        } {
+            /// Evaluates if one value of the same type is greater or equal to than another.
+            ///
+            /// # Additional Information
+            ///
+            /// This trait requires that the `Ord` and `Eq` traits are implemented.
+            ///
+            /// # Arguments
+            ///
+            /// * `other`: [Self] - The value of the same type.
+            ///
+            /// # Returns
+            ///
+            /// * [bool] - `true` if `self` is greater than or equal to `other`, otherwise `false`.
+            ///
+            /// # Examples
+            ///
+            /// ```sway
+            /// struct MyStruct {
+            ///     val: u64,
+            /// }
+            ///
+            /// impl Eq for MyStruct {
+            ///     fn eq(self, other: Self) -> bool {
+            ///         self.val == other.val
+            ///     }
+            /// }
+            ///
+            /// impl Ord for MyStruct {
+            ///     fn gt(self, other: Self) -> bool {
+            ///         self.val > other.val
+            ///     }
+            /// }
+            ///
+            /// impl OrdEq for MyStruct {}
+            ///
+            /// fn foo() {
+            ///     let struct1 = MyStruct { val: 10 };
+            ///     let struct2 = MyStruct { val: 10 };
+            ///     let result = struct1 >= struct2;
+            ///     assert(result);
+            /// }
+            /// ```
+            fn ge(self, other: Self) -> bool {
+                self.gt(other) || self.eq(other)
+            }
+            /// Some test
+            fn test() {
+
+            }
+        }
+        "#},
+        indoc! {r#"
+        library;
+
+        /// Trait to evaluate if one value is greater than or equal, or less than or equal to another of the same type.
+        trait OrdEq: Ord + Eq {
+        } {
+            /// Evaluates if one value of the same type is greater or equal to than another.
+            ///
+            /// # Additional Information
+            ///
+            /// This trait requires that the `Ord` and `Eq` traits are implemented.
+            ///
+            /// # Arguments
+            ///
+            /// * `other`: [Self] - The value of the same type.
+            ///
+            /// # Returns
+            ///
+            /// * [bool] - `true` if `self` is greater than or equal to `other`, otherwise `false`.
+            ///
+            /// # Examples
+            ///
+            /// ```sway
+            /// struct MyStruct {
+            ///     val: u64,
+            /// }
+            ///
+            /// impl Eq for MyStruct {
+            ///     fn eq(self, other: Self) -> bool {
+            ///         self.val == other.val
+            ///     }
+            /// }
+            ///
+            /// impl Ord for MyStruct {
+            ///     fn gt(self, other: Self) -> bool {
+            ///         self.val > other.val
+            ///     }
+            /// }
+            ///
+            /// impl OrdEq for MyStruct {}
+            ///
+            /// fn foo() {
+            ///     let struct1 = MyStruct { val: 10 };
+            ///     let struct2 = MyStruct { val: 10 };
+            ///     let result = struct1 >= struct2;
+            ///     assert(result);
+            /// }
+            /// ```
+            fn ge(self, other: Self) -> bool {
+                self.gt(other) || self.eq(other)
+            }
+            /// Some test
+            fn test() {}
+        }
+        "#},
     );
 }
 
 #[test]
 fn single_argument_method() {
     check(
-        r#"library;
-    
-    pub fn from_be_bytes(bytes: [u8; 32]) -> Self {
-        let a = u64::from_be_bytes(
-            [
-                bytes[0], bytes[1], bytes[2], bytes[3], bytes[4],
-                bytes[5], bytes[6], bytes[7],
-            ],
-        );
-    }
-    "#,
-        r#"library;
+        indoc! {r#"
+        library;
+        
+        pub fn from_be_bytes(bytes: [u8; 32]) -> Self {
+            let a = u64::from_be_bytes(
+                [
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4],
+                    bytes[5], bytes[6], bytes[7],
+                ],
+            );
+        }
+        "#},
+        indoc! {r#"
+        library;
 
-pub fn from_be_bytes(bytes: [u8; 32]) -> Self {
-    let a = u64::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]]);
-}
-"#,
+        pub fn from_be_bytes(bytes: [u8; 32]) -> Self {
+            let a = u64::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]]);
+        }
+        "#},
     );
 }
 
 #[test]
 fn impl_func_where() {
     check(
-        r#"library;
+        indoc! {r#"
+        library;
+
+                impl<K, V> Foo<Bar<K, V>>
+                where
+                    K: Hash,
+                {
+                    pub fn baz(self, _: K, _: V)
+                    where
+                        K: Hash,
+                {
+                        debug();
+                    }
+                }
+        "#},
+        indoc! {r#"
+        library;
 
         impl<K, V> Foo<Bar<K, V>>
         where
@@ -2931,24 +3122,36 @@ fn impl_func_where() {
             pub fn baz(self, _: K, _: V)
             where
                 K: Hash,
-        {
+            {
                 debug();
             }
         }
-    "#,
-        r#"library;
-
-impl<K, V> Foo<Bar<K, V>>
-where
-    K: Hash,
-{
-    pub fn baz(self, _: K, _: V)
-    where
-        K: Hash,
-    {
-        debug();
-    }
-}
-"#,
+        "#},
+    );
+}
+
+#[test]
+fn retain_in_keyword() {
+    check(
+        indoc! {r#"
+        contract;
+        use standards::src14::{SRC14, SRC14_TARGET_STORAGE};
+
+        storage {
+            SRC14 {
+                target   in  0x7bb458adc1d118713319a5baa00a2d049dd64d2916477d2688d76970c898cd55:ContractId  = ContractId::zero(),
+            },
+        }
+        "#},
+        indoc! {r#"
+        contract;
+        use standards::src14::{SRC14, SRC14_TARGET_STORAGE};
+
+        storage {
+            SRC14 {
+                target in 0x7bb458adc1d118713319a5baa00a2d049dd64d2916477d2688d76970c898cd55: ContractId = ContractId::zero(),
+            },
+        }
+        "#},
     );
 }
diff --git a/templates/sway-predicate-test-rs/template/Cargo.toml b/templates/sway-predicate-test-rs/template/Cargo.toml
index 2b33a5d631b..4432d7edd52 100644
--- a/templates/sway-predicate-test-rs/template/Cargo.toml
+++ b/templates/sway-predicate-test-rs/template/Cargo.toml
@@ -7,7 +7,7 @@ authors = ["{{authors}}"]
 license = "Apache-2.0"
 
 [dev-dependencies]
-fuels = { version = "0.62", features = ["fuel-core-lib"] }
+fuels = "0.66.2"
 tokio = { version = "1.12", features = ["rt", "macros"] }
 
 [[test]]
diff --git a/templates/sway-predicate-test-rs/template/build.rs b/templates/sway-predicate-test-rs/template/build.rs
new file mode 100644
index 00000000000..a92169be524
--- /dev/null
+++ b/templates/sway-predicate-test-rs/template/build.rs
@@ -0,0 +1,7 @@
+//! This build script is used to compile the sway project using `forc` prior to running tests.
+
+use std::process::Command;
+
+fn main() {
+    Command::new("forc").args(&["build"]).status().unwrap();
+}
diff --git a/templates/sway-script-test-rs/template/Cargo.toml b/templates/sway-script-test-rs/template/Cargo.toml
index 2b33a5d631b..4432d7edd52 100644
--- a/templates/sway-script-test-rs/template/Cargo.toml
+++ b/templates/sway-script-test-rs/template/Cargo.toml
@@ -7,7 +7,7 @@ authors = ["{{authors}}"]
 license = "Apache-2.0"
 
 [dev-dependencies]
-fuels = { version = "0.62", features = ["fuel-core-lib"] }
+fuels = "0.66.2"
 tokio = { version = "1.12", features = ["rt", "macros"] }
 
 [[test]]
diff --git a/templates/sway-script-test-rs/template/build.rs b/templates/sway-script-test-rs/template/build.rs
new file mode 100644
index 00000000000..a92169be524
--- /dev/null
+++ b/templates/sway-script-test-rs/template/build.rs
@@ -0,0 +1,7 @@
+//! This build script is used to compile the sway project using `forc` prior to running tests.
+
+use std::process::Command;
+
+fn main() {
+    Command::new("forc").args(&["build"]).status().unwrap();
+}
diff --git a/templates/sway-test-rs/template/Cargo.toml b/templates/sway-test-rs/template/Cargo.toml
index 416feb395ab..4432d7edd52 100644
--- a/templates/sway-test-rs/template/Cargo.toml
+++ b/templates/sway-test-rs/template/Cargo.toml
@@ -7,7 +7,7 @@ authors = ["{{authors}}"]
 license = "Apache-2.0"
 
 [dev-dependencies]
-fuels = { version = "0.62.0", features = ["fuel-core-lib"] }
+fuels = "0.66.2"
 tokio = { version = "1.12", features = ["rt", "macros"] }
 
 [[test]]
diff --git a/templates/sway-test-rs/template/build.rs b/templates/sway-test-rs/template/build.rs
new file mode 100644
index 00000000000..a92169be524
--- /dev/null
+++ b/templates/sway-test-rs/template/build.rs
@@ -0,0 +1,7 @@
+//! This build script is used to compile the sway project using `forc` prior to running tests.
+
+use std::process::Command;
+
+fn main() {
+    Command::new("forc").args(&["build"]).status().unwrap();
+}
diff --git a/test/Cargo.toml b/test/Cargo.toml
index 92479161ca0..3854b55f458 100644
--- a/test/Cargo.toml
+++ b/test/Cargo.toml
@@ -6,32 +6,42 @@ authors.workspace = true
 edition.workspace = true
 
 [dependencies]
-anyhow = "1.0.41"
-bytes = "1.3.0"
-clap = { version = "4.5.4", features = ["derive", "env"] }
-colored = "2.0.0"
-filecheck = "0.5"
-forc = { path = "../forc", features = ["test"], default-features = false }
-forc-client = { path = "../forc-plugins/forc-client" }
-forc-pkg = { path = "../forc-pkg" }
-forc-test = { path = "../forc-test" }
-forc-tracing = { path = "../forc-tracing" }
+anyhow.workspace = true
+bytes.workspace = true
+clap = { workspace = true, features = ["derive", "env"] }
+colored.workspace = true
+duct = "0.13.7"
+filecheck.workspace = true
+forc = { workspace = true, features = ["test"] }
+forc-client.workspace = true
+forc-pkg.workspace = true
+forc-test.workspace = true
+forc-tracing.workspace = true
 fuel-vm = { workspace = true, features = ["random"] }
-futures = "0.3.24"
-gag = "1.0"
-hex = "0.4.3"
-miden = "0.3.0"
-prettydiff = "0.6"
-rand = "0.8"
-regex = "1.7"
-revm = "2.3.1"
-serde_json = "1.0.73"
-sway-core = { path = "../sway-core" }
-sway-error = { path = "../sway-error" }
-sway-ir = { path = "../sway-ir" }
-sway-types = { path = "../sway-types" }
-sway-utils = { path = "../sway-utils" }
-textwrap = "0.16.0"
-tokio = "1.12"
-toml = { version = "0.7", features = ["parse"] }
-tracing = "0.1"
+futures.workspace = true
+gag.workspace = true
+glob.workspace = true
+hex.workspace = true
+insta.workspace = true
+libtest-mimic.workspace = true
+normalize-path = "0.2.1"
+prettydiff.workspace = true
+rand.workspace = true
+regex.workspace = true
+revm.workspace = true
+serde_json.workspace = true
+sway-core.workspace = true
+sway-error.workspace = true
+sway-ir.workspace = true
+sway-types.workspace = true
+sway-utils.workspace = true
+textwrap.workspace = true
+tokio.workspace = true
+toml = { workspace = true, features = ["parse"] }
+tracing.workspace = true
+vte.workspace = true
+
+[[test]]
+name = "tests"
+path = "tests/tests.rs"
+harness = false
diff --git a/test/bench.sh b/test/bench.sh
index 67021473701..f20ed5e29df 100755
--- a/test/bench.sh
+++ b/test/bench.sh
@@ -83,7 +83,7 @@ if [[ $CLEAN = "all" ]]; then
     exit 0
 fi
 
-PROJ_NAME="$(basename $PROJ_PATH)"
+
 
 # install dependencies
 if ! command -v hyperfine &>> "$LOG_FILE"
@@ -122,20 +122,25 @@ if [ -n "$QUANTITY" ]; then
             cp target/release/forc "$CACHE/$COMMIT" &>> "$LOG_FILE"
         fi
 
-        # run test if needed
-        if [ ! -f "$CACHE/$COMMIT-$PROJ_NAME.csv" ]; then
-            echo -e -n " [benchmark]"
-            hyperfine -n "$COMMIT-$PROJ_NAME" --export-csv "$CACHE/$COMMIT-$PROJ_NAME.csv" "$CACHE/$COMMIT build -p $PROJ_PATH --release" &>> "$LOG_FILE"
-        fi
-
-        # get binary size if needed
-        if [ ! -f "$CACHE/$COMMIT-$PROJ_NAME-size.txt" ]; then
-            echo -e -n " [bin size]"
-            rm "$PROJ_PATH/out" -rf &>> "$LOG_FILE"
-            bash -c "$CACHE/$COMMIT build -p $PROJ_PATH --release" &>> "$LOG_FILE"
-            stat --printf="%s" "$PROJ_PATH/out/release/$PROJ_NAME.bin" > "$CACHE/$COMMIT-$PROJ_NAME-size.txt"
-        fi
-
+        # for each project specified
+        for CURRENT_PROJECT_PATH in ${PROJ_PATH//,/ }
+        do
+            PROJ_NAME="$(basename $CURRENT_PROJECT_PATH)"
+
+            # run test if needed
+            if [ ! -f "$CACHE/$COMMIT-$PROJ_NAME.csv" ]; then
+                echo -e -n " [$PROJ_NAME bench]"
+                hyperfine -n "$COMMIT-$PROJ_NAME" --export-csv "$CACHE/$COMMIT-$PROJ_NAME.csv" "$CACHE/$COMMIT build -p $CURRENT_PROJECT_PATH --release" &>> "$LOG_FILE"
+            fi
+
+            # get binary size if needed
+            if [ ! -f "$CACHE/$COMMIT-$PROJ_NAME-size.txt" ]; then
+                echo -e -n " [$PROJ_NAME size]"
+                rm "$CURRENT_PROJECT_PATH/out" -rf &>> "$LOG_FILE"
+                bash -c "$CACHE/$COMMIT build -p $CURRENT_PROJECT_PATH --release" &>> "$LOG_FILE"
+                stat --printf="%s" "$CURRENT_PROJECT_PATH/out/release/$PROJ_NAME.bin" > "$CACHE/$COMMIT-$PROJ_NAME-size.txt"
+            fi
+        done
         echo -e " ${BOLD_GREEN}ok${NC}"
     done
 fi
diff --git a/test/src/e2e_vm_tests/README.md b/test/src/e2e_vm_tests/README.md
index 2bc1b02bfc8..1f71421bf8a 100644
--- a/test/src/e2e_vm_tests/README.md
+++ b/test/src/e2e_vm_tests/README.md
@@ -3,11 +3,15 @@
 In order to minimize compilation time of individual tests, strive to reduce dependencies in tests.
 
 To achieve that, follow these guidelines:
+
 - Use `implicit-std = false` if dependency on `core` is not needed. This is often possible when testing `should_pass/language` features.
+- If the dependency on `core` is not needed, instead of using the project type `script`, that will, because of the encoding, depend on `core`, try using `library` instead.
 - Do not use `std` just to conveniently get an arbitrary type or trait. E.g., if a test requires an arbitrary type or trait, go with `struct Dummy {}` or `trait Trait {}` instead of importing `Option` or `Hash`.
 - If `std` functionality is needed, import the minimal [reduced `std` library](reduced_std_libs/README.md) that provides the functionality.
 - Import the full `std` only if the provided [reduced `std` libraries](reduced_std_libs/README.md) do not provide required types.
 
+Additionally, try to meaningfully group tests with high cohesion, rather then splitting them into several tests. Having only one test project reduces compilation time. E.g., instead of having two tests `test_some_feature_for_option_a` and `test_some_feature_for_option_b`, try having just `test_some_feature` and the two cases tested in, e.g., modules in that one test. Makes sure, though, that such test groupings are meaningful. We don't want to end up having artificially combined tests.
+
 # Running end-to-end VM tests
 
 This document assumes you have `fuel-core` running on the default port.
@@ -84,3 +88,17 @@ SWAY_TEST_VERBOSE=true cargo run [pattern]
 ```
 
 from the `sway/test` directory.
+
+# Snapshot tests
+
+When an "e2e" test has a file named `snapshot.toml` it will run as `cargo insta` snapshot tests.
+These tests can be run as normal: `cargo r -p test`, and in two new ways:
+
+```
+> cargo t -p test
+> cargo insta test
+```
+
+Snapshots can be reviewed using normal "cargo insta" workflow (see [insta.rs](https://insta.rs/)).
+
+For the moment, there is no configuration for `snapshot.toml`, so they are just empty files.
diff --git a/test/src/e2e_vm_tests/harness.rs b/test/src/e2e_vm_tests/harness.rs
index 4133feb08d5..6168b1f4236 100644
--- a/test/src/e2e_vm_tests/harness.rs
+++ b/test/src/e2e_vm_tests/harness.rs
@@ -2,7 +2,7 @@ use anyhow::{anyhow, bail, Result};
 use colored::Colorize;
 use forc_client::{
     cmd::{Deploy as DeployCommand, Run as RunCommand},
-    op::{deploy, run},
+    op::{deploy, run, DeployedPackage},
     NodeTarget,
 };
 use forc_pkg::{
@@ -67,7 +67,7 @@ pub(crate) async fn deploy_contract(file_name: &str, run_config: &RunConfig) ->
     println!(" Deploying {} ...", file_name.bold());
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
 
-    deploy(DeployCommand {
+    let deployed_packages = deploy(DeployCommand {
         pkg: forc_client::cmd::deploy::Pkg {
             path: Some(format!(
                 "{manifest_dir}/src/e2e_vm_tests/test_programs/{file_name}"
@@ -85,13 +85,20 @@ pub(crate) async fn deploy_contract(file_name: &str, run_config: &RunConfig) ->
         no_encoding_v1: !run_config.experimental.new_encoding,
         ..Default::default()
     })
-    .await
-    .map(|contract_ids| {
-        contract_ids
-            .first()
-            .map(|contract_id| contract_id.id)
-            .unwrap()
-    })
+    .await?;
+
+    deployed_packages
+        .into_iter()
+        .map(|deployed_pkg| {
+            if let DeployedPackage::Contract(deployed_contract) = deployed_pkg {
+                Some(deployed_contract.id)
+            } else {
+                None
+            }
+        })
+        .next()
+        .flatten()
+        .ok_or_else(|| anyhow!("expected to find at least one deployed contract."))
 }
 
 /// Run a given project against a node. Assumes the node is running at localhost:4000.
@@ -140,8 +147,7 @@ pub(crate) async fn runs_on_node(
 
 pub(crate) enum VMExecutionResult {
     Fuel(ProgramState, Vec<Receipt>),
-    Evm(revm::ExecutionResult),
-    MidenVM(miden::ExecutionTrace),
+    Evm(revm::primitives::result::ExecutionResult),
 }
 
 /// Very basic check that code does indeed run in the VM.
@@ -203,8 +209,9 @@ pub(crate) fn runs_in_vm(
                 .into_ready(gas_price, params.gas_costs(), params.fee_params())
                 .map_err(|e| anyhow::anyhow!("{e:?}"))?;
 
-            let mut i: Interpreter<_, _, NotSupportedEcal> =
-                Interpreter::with_storage(storage, Default::default());
+            let mem_instance = MemoryInstance::new();
+            let mut i: Interpreter<_, _, _, NotSupportedEcal> =
+                Interpreter::with_storage(mem_instance, storage, Default::default());
             let transition = i.transact(tx).map_err(anyhow::Error::msg)?;
 
             Ok(VMExecutionResult::Fuel(
@@ -213,52 +220,40 @@ pub(crate) fn runs_in_vm(
             ))
         }
         BuildTarget::EVM => {
-            let mut evm = revm::new();
-            evm.database(revm::InMemoryDB::default());
-            evm.env = revm::Env::default();
+            let mut evm = revm::EvmBuilder::default()
+                .with_db(revm::InMemoryDB::default())
+                .with_clear_env()
+                .build();
 
             // Transaction to create the smart contract
-            evm.env.tx.transact_to = revm::TransactTo::create();
-            evm.env.tx.data = bytes::Bytes::from(script.bytecode.bytes.into_boxed_slice());
-            let result = evm.transact_commit();
-
-            match result.out {
-                revm::TransactOut::None => Err(anyhow!("Could not create smart contract")),
-                revm::TransactOut::Call(_) => todo!(),
-                revm::TransactOut::Create(ref _bytes, account_opt) => {
-                    match account_opt {
-                        Some(account) => {
-                            evm.env.tx.transact_to = revm::TransactTo::Call(account);
-
-                            // Now issue a call.
-                            //evm.env.tx. = bytes::Bytes::from(script.bytecode.into_boxed_slice());
-                            let result = evm.transact_commit();
-                            Ok(VMExecutionResult::Evm(result))
+            let result = evm
+                .transact_commit()
+                .map_err(|e| anyhow::anyhow!("Could not create smart contract on EVM: {e:?}"))?;
+
+            match result {
+                revm::primitives::ExecutionResult::Revert { .. }
+                | revm::primitives::ExecutionResult::Halt { .. } => todo!(),
+                revm::primitives::ExecutionResult::Success { ref output, .. } => match output {
+                    revm::primitives::result::Output::Call(_) => todo!(),
+                    revm::primitives::result::Output::Create(_bytes, address_opt) => {
+                        match address_opt {
+                            None => todo!(),
+                            Some(address) => {
+                                evm.tx_mut().data = script.bytecode.bytes.into();
+                                evm.tx_mut().transact_to =
+                                    revm::interpreter::primitives::TransactTo::Call(*address);
+
+                                let result = evm
+                                    .transact_commit()
+                                    .map_err(|e| anyhow::anyhow!("Failed call on EVM: {e:?}"))?;
+
+                                Ok(VMExecutionResult::Evm(result))
+                            }
                         }
-                        None => todo!(),
                     }
-                }
+                },
             }
         }
-        BuildTarget::MidenVM => {
-            use miden::{Assembler, ProgramInputs};
-
-            // instantiate the assembler
-            let assembler = Assembler::default();
-
-            let bytecode_str = std::str::from_utf8(&script.bytecode.bytes)?;
-
-            // compile Miden assembly source code into a program
-            let program = assembler.compile(bytecode_str).unwrap();
-
-            // execute the program with no inputs
-            let _trace = miden::execute(&program, &ProgramInputs::none()).unwrap();
-
-            let execution_trace = miden::execute(&program, &ProgramInputs::none())
-                .map_err(|e| anyhow::anyhow!("Failed to execute on MidenVM: {e:?}"))?;
-
-            Ok(VMExecutionResult::MidenVM(execution_trace))
-        }
     }
 }
 
@@ -277,6 +272,7 @@ pub(crate) async fn compile_to_bytes(file_name: &str, run_config: &RunConfig) ->
             dca_graph_url_format: None,
             asm: run_config.print_asm,
             bytecode: run_config.print_bytecode,
+            bytecode_spans: run_config.print_bytecode,
             ir: run_config.print_ir.clone(),
             reverse_order: false,
         },
@@ -286,7 +282,6 @@ pub(crate) async fn compile_to_bytes(file_name: &str, run_config: &RunConfig) ->
             )),
             locked: run_config.locked,
             terse: false,
-            json_abi_with_callpaths: true,
             ..Default::default()
         },
         experimental: ExperimentalFlags {
diff --git a/test/src/e2e_vm_tests/mod.rs b/test/src/e2e_vm_tests/mod.rs
index 027971477f8..7eaca4d658b 100644
--- a/test/src/e2e_vm_tests/mod.rs
+++ b/test/src/e2e_vm_tests/mod.rs
@@ -9,12 +9,14 @@ use crate::{FilterConfig, RunConfig};
 use anyhow::{anyhow, bail, Result};
 use colored::*;
 use core::fmt;
+use forc_pkg::manifest::{GenericManifestFile, ManifestFile};
 use forc_pkg::BuildProfile;
 use forc_test::decode_log_data;
 use fuel_vm::fuel_tx;
+use fuel_vm::fuel_types::canonical::Input;
 use fuel_vm::prelude::*;
 use regex::Regex;
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::io::stdout;
 use std::io::Write;
 use std::str::FromStr;
@@ -113,6 +115,8 @@ struct TestContext {
 }
 
 fn print_receipts(output: &mut String, receipts: &[Receipt]) {
+    let mut text_log = String::new();
+
     use std::fmt::Write;
     let _ = writeln!(output, "  {}", "Receipts".green().bold());
     for (i, receipt) in receipts.iter().enumerate() {
@@ -129,6 +133,28 @@ fn print_receipts(output: &mut String, receipts: &[Receipt]) {
                 is,
                 data,
             } => {
+                // Small hack to allow log from tests.
+                if *ra == u64::MAX {
+                    match rb {
+                        0 => {
+                            let mut data = data.as_deref().unwrap();
+                            data.skip(8).unwrap();
+                            let s = std::str::from_utf8(data).unwrap();
+
+                            text_log.push_str(s);
+                        }
+                        1 => {
+                            let data = data.as_deref().unwrap();
+                            let s = u64::from_be_bytes(data.try_into().unwrap());
+
+                            text_log.push_str(&format!("{}", s));
+                        }
+                        2 => {
+                            text_log.push('\n');
+                        }
+                        _ => {}
+                    }
+                }
                 let _ = write!(output, " LogData\n      ID: {id:?}\n      RA: {ra:?}\n      RB: {rb:?}\n      Ptr: {ptr:?}\n      Len: {len:?}\n      Digest: {digest:?}\n      PC: {pc:?}\n      IS: {is:?}\n      Data: {data:?}\n");
             }
             Receipt::ReturnData {
@@ -238,6 +264,14 @@ fn print_receipts(output: &mut String, receipts: &[Receipt]) {
             }
         }
     }
+
+    if !text_log.is_empty() {
+        let _ = writeln!(output, "  {}", "Text Logs".green().bold());
+
+        for l in text_log.lines() {
+            let _ = writeln!(output, "{l}");
+        }
+    }
 }
 
 impl TestContext {
@@ -302,6 +336,41 @@ impl TestContext {
                     run_and_capture_output(|| harness::compile_to_bytes(&name, &run_config)).await;
                 *output = out;
 
+                if let Ok(result) = result.as_ref() {
+                    let packages = match result {
+                        forc_pkg::Built::Package(p) => [p.clone()].to_vec(),
+                        forc_pkg::Built::Workspace(p) => p.clone(),
+                    };
+
+                    for p in packages {
+                        let bytecode_len = p.bytecode.bytes.len();
+
+                        let configurables = match &p.program_abi {
+                            sway_core::asm_generation::ProgramABI::Fuel(abi) => {
+                                abi.configurables.as_ref().cloned().unwrap_or_default()
+                            }
+                            sway_core::asm_generation::ProgramABI::Evm(_)
+                            | sway_core::asm_generation::ProgramABI::MidenVM(_) => vec![],
+                        }
+                        .into_iter()
+                        .map(|x| (x.offset, x.name))
+                        .collect::<BTreeMap<u64, String>>();
+
+                        let mut items = configurables.iter().peekable();
+                        while let Some(current) = items.next() {
+                            let next_offset = match items.peek() {
+                                Some(next) => *next.0,
+                                None => bytecode_len as u64,
+                            };
+                            let size = next_offset - current.0;
+                            output.push_str(&format!(
+                                "Configurable Encoded Bytes Buffer Size: {} {}\n",
+                                current.1, size
+                            ));
+                        }
+                    }
+                }
+
                 check_file_checker(checker, &name, output)?;
 
                 let compiled = result?;
@@ -345,23 +414,18 @@ impl TestContext {
                             }
                         }
                     }
-                    harness::VMExecutionResult::Evm(state) => match state.exit_reason {
-                        revm::Return::Continue => todo!(),
-                        revm::Return::Stop => TestResult::Result(0),
-                        revm::Return::Return => todo!(),
-                        revm::Return::SelfDestruct => todo!(),
-                        revm::Return::Revert => TestResult::Revert(0),
-                        _ => {
-                            panic!("EVM exited with unhandled reason: {:?}", state.exit_reason);
+                    harness::VMExecutionResult::Evm(state) => match state {
+                        revm::primitives::ExecutionResult::Success { reason, .. } => match reason {
+                            revm::primitives::SuccessReason::Stop => TestResult::Result(0),
+                            revm::primitives::SuccessReason::Return => todo!(),
+                            revm::primitives::SuccessReason::SelfDestruct => todo!(),
+                            revm::primitives::SuccessReason::EofReturnContract => todo!(),
+                        },
+                        revm::primitives::ExecutionResult::Revert { .. } => TestResult::Result(0),
+                        revm::primitives::ExecutionResult::Halt { reason, .. } => {
+                            panic!("EVM exited with unhandled reason: {:?}", reason);
                         }
                     },
-                    harness::VMExecutionResult::MidenVM(trace) => {
-                        let outputs = trace.program_outputs();
-                        let stack = outputs.stack();
-                        // for now, just test primitive u64s.
-                        // Later on, we can test stacks that have more elements in them.
-                        TestResult::Return(stack[0])
-                    }
                 };
 
                 if actual_result != expected_result {
@@ -425,8 +489,8 @@ impl TestContext {
                             )
                         })
                         .await;
-                        result?;
                         output.push_str(&out);
+                        result?;
                     }
                 }
 
@@ -653,6 +717,13 @@ pub async fn run(filter_config: &FilterConfig, run_config: &RunConfig) -> Result
         .as_ref()
         .map(|exclude| tests.retained(|t| !exclude.is_match(&t.name)))
         .unwrap_or_default();
+
+    if filter_config.exclude_core {
+        tests.retain(|t| exclude_tests_dependency(t, "core"));
+    }
+    if filter_config.exclude_std {
+        tests.retain(|t| exclude_tests_dependency(t, "std"));
+    }
     if filter_config.abi_only {
         tests.retain(|t| t.validate_abi);
     }
@@ -663,36 +734,6 @@ pub async fn run(filter_config: &FilterConfig, run_config: &RunConfig) -> Result
         tests = vec![tests.remove(0)];
     }
 
-    // Expand tests that need to run with multiple configurations.
-    // Be mindful that this can explode exponentially the number of tests
-    // that run because one expansion expands on top of another
-    let mut tests = tests;
-    let expansions: [&str; 0] = [];
-    for expansion in expansions {
-        tests = tests
-            .into_iter()
-            .flat_map(|t| {
-                let has_script_data_new_encoding = t.script_data_new_encoding.is_some();
-                let has_contracts = !t.contract_paths.is_empty();
-                let has_expected_return = t.expected_result_new_encoding.is_some();
-                if expansion == "new_encoding"
-                    && (has_script_data_new_encoding || has_contracts || has_expected_return)
-                {
-                    let mut with_new_encoding = t.clone();
-                    with_new_encoding.suffix = Some("New Encoding".into());
-
-                    let mut run_config_with_new_encoding = run_config.clone();
-                    run_config_with_new_encoding.experimental.new_encoding = true;
-                    with_new_encoding.run_config = run_config_with_new_encoding;
-
-                    vec![t, with_new_encoding]
-                } else {
-                    vec![t]
-                }
-            })
-            .collect();
-    }
-
     // Run tests
     let context = TestContext {
         deployed_contracts: Default::default(),
@@ -822,6 +863,25 @@ pub async fn run(filter_config: &FilterConfig, run_config: &RunConfig) -> Result
     }
 }
 
+fn exclude_tests_dependency(t: &TestDescription, dep: &str) -> bool {
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    let tests_root_dir = format!("{manifest_dir}/src/e2e_vm_tests/test_programs");
+    let file_name = &t.name;
+    let manifest_path = format!("{tests_root_dir}/{file_name}");
+    match ManifestFile::from_dir(manifest_path) {
+        Ok(manifest_file) => {
+            let member_manifests = manifest_file.member_manifests().unwrap();
+            !member_manifests.iter().any(|(_name, manifest)| {
+                manifest
+                    .dependencies
+                    .as_ref()
+                    .is_some_and(|map| map.contains_key(dep))
+            })
+        }
+        Err(_) => true,
+    }
+}
+
 fn discover_test_configs(run_config: &RunConfig) -> Result<Vec<TestDescription>> {
     fn recursive_search(
         path: &Path,
@@ -873,7 +933,7 @@ fn check_file_checker(checker: filecheck::Checker, name: &String, output: &str)
 fn parse_test_toml(path: &Path, run_config: &RunConfig) -> Result<TestDescription> {
     let toml_content_str = std::fs::read_to_string(path)?;
 
-    let file_check = FileCheck(toml_content_str.clone());
+    let mut file_check = FileCheck(toml_content_str.clone());
     let checker = file_check.build()?;
 
     let toml_content = toml_content_str.parse::<toml::Value>()?;
@@ -882,8 +942,17 @@ fn parse_test_toml(path: &Path, run_config: &RunConfig) -> Result<TestDescriptio
         bail!("Malformed test description.");
     }
 
-    let category = toml_content
-        .get("category")
+    // if new encoding is on, allow a "category_new_encoding"
+    // for tests that should have different categories
+    let category = if run_config.experimental.new_encoding {
+        toml_content
+            .get("category_new_encoding")
+            .or_else(|| toml_content.get("category"))
+    } else {
+        toml_content.get("category")
+    };
+
+    let category = category
         .ok_or_else(|| anyhow!("Missing mandatory 'category' entry."))
         .and_then(|category_val| match category_val.as_str() {
             Some("run") => Ok(TestCategory::Runs),
@@ -916,6 +985,18 @@ fn parse_test_toml(path: &Path, run_config: &RunConfig) -> Result<TestDescriptio
         bail!("'fail' tests must contain some FileCheck verification directives.");
     }
 
+    // We have some tests on old and new encoding that return different warnings.
+    // There is no easy way to write `test.toml` to support both, and the effort
+    // for such support is also questionable since we do not want to support
+    // the old encoding anymore, and currently we do not have any other configurations.
+    // Currently, we will simply ignore the `FileCheck` directives if the test category
+    // is not "fails" and the "category_new_encoding" is explicitly specified.
+    if toml_content.get("category_new_encoding").is_some()
+        && category != TestCategory::FailsToCompile
+    {
+        file_check = FileCheck("".into());
+    }
+
     let (script_data, script_data_new_encoding) = match &category {
         TestCategory::Runs | TestCategory::RunsWithContract => {
             let script_data = match toml_content.get("script_data") {
@@ -984,7 +1065,7 @@ fn parse_test_toml(path: &Path, run_config: &RunConfig) -> Result<TestDescriptio
 
     let expected_result = match &category {
         TestCategory::Runs | TestCategory::RunsWithContract => {
-            Some(get_expected_result("expected_result", &toml_content)?)
+            get_expected_result("expected_result", &toml_content)
         }
         TestCategory::Compiles
         | TestCategory::FailsToCompile
@@ -996,7 +1077,7 @@ fn parse_test_toml(path: &Path, run_config: &RunConfig) -> Result<TestDescriptio
         &category,
         get_expected_result("expected_result_new_encoding", &toml_content),
     ) {
-        (TestCategory::Runs | TestCategory::RunsWithContract, Ok(value)) => Some(value),
+        (TestCategory::Runs | TestCategory::RunsWithContract, Some(value)) => Some(value),
         _ => None,
     };
 
@@ -1077,7 +1158,11 @@ fn parse_test_toml(path: &Path, run_config: &RunConfig) -> Result<TestDescriptio
 
     Ok(TestDescription {
         name,
-        suffix: None,
+        suffix: if run_config.experimental.new_encoding {
+            None
+        } else {
+            Some("encoding v0".into())
+        },
         category,
         script_data,
         script_data_new_encoding,
@@ -1117,7 +1202,7 @@ fn get_build_profile_from_value(value: &toml::Value) -> Result<&'static str> {
     }
 }
 
-fn get_expected_result(key: &str, toml_content: &toml::Value) -> Result<TestResult> {
+fn get_expected_result(key: &str, toml_content: &toml::Value) -> Option<TestResult> {
     fn get_action_value(action: &toml::Value, expected_value: &toml::Value) -> Result<TestResult> {
         match (action.as_str(), expected_value) {
             // A simple integer value.
@@ -1138,22 +1223,8 @@ fn get_expected_result(key: &str, toml_content: &toml::Value) -> Result<TestResu
         }
     }
 
-    toml_content
-        .get(key)
-        .ok_or_else(|| anyhow!( "Could not find mandatory 'expected_result' entry."))
-        .and_then(|expected_result_table| {
-            expected_result_table
-                .get("action")
-                .ok_or_else(|| {
-                    anyhow!("Could not find mandatory 'action' field in 'expected_result' entry.")
-                })
-                .and_then(|action| {
-                    expected_result_table
-                        .get("value")
-                        .ok_or_else(|| {
-                            anyhow!("Could not find mandatory 'value' field in 'expected_result' entry.")
-                        })
-                        .and_then(|expected_value| get_action_value(action, expected_value))
-                })
-        })
+    let expected_result_table = toml_content.get(key)?;
+    let action = expected_result_table.get("action")?;
+    let value = expected_result_table.get("value")?;
+    get_action_value(action, value).ok()
 }
diff --git a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/prelude.sw b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/prelude.sw
index 06236c60050..8384a72644d 100644
--- a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/prelude.sw
+++ b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/prelude.sw
@@ -4,8 +4,8 @@
 library;
 
 // Error handling
-use ::assert::{assert, assert_eq, assert_ne};
-use ::revert::{require, revert};
+pub use ::assert::{assert, assert_eq, assert_ne};
+pub use ::revert::{require, revert};
 
 // Logging
-use ::logging::log;
+pub use ::logging::log;
diff --git a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-conversions/src/prelude.sw b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-conversions/src/prelude.sw
index 90fbbfa875c..7f98f5cd2b4 100644
--- a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-conversions/src/prelude.sw
+++ b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-conversions/src/prelude.sw
@@ -4,25 +4,25 @@
 library;
 
 // Collections
-use ::vec::{Vec, VecIter};
+pub use ::vec::{Vec, VecIter};
 
 // Error handling
-use ::assert::{assert, assert_eq, assert_ne};
-use ::option::Option::{self, *};
-use ::result::Result::{self, *};
-use ::revert::{require, revert};
+pub use ::assert::{assert, assert_eq, assert_ne};
+pub use ::option::Option::{self, *};
+pub use ::result::Result::{self, *};
+pub use ::revert::{require, revert};
 
 // Convert
-use ::convert::From;
+pub use ::convert::From;
 
 /// U128
-use ::u128::*;
+pub use ::u128::*;
 
 // Primitive conversions
-use ::primitive_conversions::{b256::*, str::*, u16::*, u256::*, u32::*, u64::*, u8::*,};
+pub use ::primitive_conversions::{b256::*, str::*, u16::*, u256::*, u32::*, u64::*, u8::*,};
 
 // Logging
-use ::logging::log;
+pub use ::logging::log;
 
 // Math
-use ::math::*;
+pub use ::math::*;
diff --git a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/src/prelude.sw b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/src/prelude.sw
index 1c6a59c2c6d..c96103fa4b0 100644
--- a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/src/prelude.sw
+++ b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/src/prelude.sw
@@ -4,10 +4,10 @@
 library;
 
 // Error handling
-use ::assert::{assert, assert_eq, assert_ne};
-use ::option::Option::{self, *};
-use ::result::Result::{self, *};
-use ::revert::{require, revert};
+pub use ::assert::{assert, assert_eq, assert_ne};
+pub use ::option::Option::{self, *};
+pub use ::result::Result::{self, *};
+pub use ::revert::{require, revert};
 
 // Logging
-use ::logging::log;
+pub use ::logging::log;
diff --git a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/src/prelude.sw b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/src/prelude.sw
index 6d02ccb3dba..990bde12d23 100644
--- a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/src/prelude.sw
+++ b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/src/prelude.sw
@@ -4,16 +4,16 @@
 library;
 
 // Collections
-use ::vec::{Vec, VecIter};
+pub use ::vec::{Vec, VecIter};
 
 // Error handling
-use ::assert::{assert, assert_eq, assert_ne};
-use ::option::Option::{self, *};
-use ::result::Result::{self, *};
-use ::revert::{require, revert};
+pub use ::assert::{assert, assert_eq, assert_ne};
+pub use ::option::Option::{self, *};
+pub use ::result::Result::{self, *};
+pub use ::revert::{require, revert};
 
 // Convert
-use ::convert::From;
+pub use ::convert::From;
 
 // Logging
-use ::logging::log;
+pub use ::logging::log;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/Forc.lock
new file mode 100644
index 00000000000..2ab463c481c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "abi_associated_const_access_with_impl_in_contract"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/Forc.toml
new file mode 100644
index 00000000000..c00f59c6f30
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "abi_associated_const_access_with_impl_in_contract"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/src/main.sw
new file mode 100644
index 00000000000..b4649062db8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/src/main.sw
@@ -0,0 +1,17 @@
+contract;
+
+abi ConstantId {
+    const ID: u32 = 0;
+}
+
+impl ConstantId for Contract {
+    const ID: u32 = 1;
+}
+
+fn main() -> u32 {
+  let _ = ConstantId::ID;
+
+  // Leave enough space to avoid having both `let` lines in both error messages.
+
+  let _ = Contract::ID;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/test.toml
new file mode 100644
index 00000000000..db48e353132
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_access_with_impl_in_contract/test.toml
@@ -0,0 +1,7 @@
+category = "fail"
+
+#check: $()let _ = ConstantId::ID;
+#nextln: $()Could not find symbol "ID" in this scope.
+
+#check: $()let _ = Contract::ID;
+#nextln: $()Could not find symbol "ID" in this scope.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_impl/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_impl/src/main.sw
index 2035e3c3384..91e13e57868 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_impl/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_impl/src/main.sw
@@ -1,14 +1,7 @@
-script;
+contract;
 
 abi ConstantId {
     const ID: u32;
 }
 
-struct Struct {}
-
-impl ConstantId for Struct {
-}
-
-fn main() -> u32 {
-  0
-}
+impl ConstantId for Contract { }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_type_ascription/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_type_ascription/src/main.sw
index 613b843d780..15a467a4eb8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_type_ascription/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_missing_type_ascription/src/main.sw
@@ -1,9 +1,5 @@
-script;
+library;
 
 abi ConstantId {
     const ID;
 }
-
-fn main() -> u32 {
-  0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_multiple_same_name/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_multiple_same_name/src/main.sw
index 80a9d25d197..8801bf519cd 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_multiple_same_name/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_associated_const_multiple_same_name/src/main.sw
@@ -1,10 +1,6 @@
-script;
+library;
 
 abi ConstantId {
     const ID: u32;
     const ID: u32;
 }
-
-fn main() -> u32 {
-  0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.lock
index a33bdc00acc..63d163df6ac 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
-name = 'abi_pure_calls_impure'
-source = 'member'
+name = "abi_pure_calls_impure"
+source = "member"
+dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-966EA6A554E875FB"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.toml
index d80c89b5739..e473123a27a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/Forc.toml
@@ -4,3 +4,6 @@ authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/src/main.sw
index 0c20e9c3856..8e8085fe9a9 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/src/main.sw
@@ -12,5 +12,6 @@ impl MyContract for Contract {
 
 #[storage(read)]
 fn f() -> bool {
+    let _ = __state_load_word(b256::zero());
     true
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/test.toml
index 19bab69fb33..2ce9f943995 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/abi_pure_calls_impure/test.toml
@@ -1,4 +1,9 @@
 category = "fail"
 
-# check: f()
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test_function() -> bool
+#nextln: $()Function "test_function" is pure and cannot access storage.
+#check: $()f()
+#nextln: $()Function "f" reads from the storage.
+#check: $()Consider declaring the function "test_function" as `#[storage(read)]`
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob/test.toml
index f4fb799b640..059ddb65458 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob/test.toml
@@ -1,3 +1,3 @@
 category = "fail"
 
-# check: $()Array index out of bounds; the length is 3 but the index is 4.
+# check: $()Index out of bounds; the length is 3 but the index is 4.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.lock
index d3ad4d4bee5..238aada9097 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.lock
@@ -1,13 +1,8 @@
 [[package]]
-name = 'array_oob_global_const_index'
-source = 'member'
-dependencies = ['std']
+name = "array_oob_global_const_index"
+source = "member"
+dependencies = ["core"]
 
 [[package]]
-name = 'core'
-source = 'path+from-root-FA9005293D2605B5'
-
-[[package]]
-name = 'std'
-source = 'path+from-root-FA9005293D2605B5'
-dependencies = ['core']
+name = "core"
+source = "path+from-root-FA9005293D2605B5"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.toml
index 7e92ee3dd54..3c68b278199 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/Forc.toml
@@ -3,6 +3,7 @@ authors = ["Fuel Labs <contact@fuel.sh>"]
 license = "Apache-2.0"
 name = "array_oob_global_const_index"
 entry = "main.sw"
+implicit-std = false
 
 [dependencies]
-std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/src/main.sw
index 50e9afafcd5..009ccdb0ee5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/src/main.sw
@@ -1,9 +1,9 @@
 script;
 
-const i: u64 = 4;
+const I: u64 = 4;
 
 fn main() -> u64 {
     // index out of bounds: the length is 3 but the index is 4
     let ary = [1, 2, 3];
-    ary[i]
+    ary[I]
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/test.toml
index f4fb799b640..059ddb65458 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/test.toml
@@ -1,3 +1,3 @@
 category = "fail"
 
-# check: $()Array index out of bounds; the length is 3 but the index is 4.
+# check: $()Index out of bounds; the length is 3 but the index is 4.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_variable_index/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_variable_index/test.toml
index f4fb799b640..059ddb65458 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_variable_index/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_variable_index/test.toml
@@ -1,3 +1,3 @@
 category = "fail"
 
-# check: $()Array index out of bounds; the length is 3 but the index is 4.
+# check: $()Index out of bounds; the length is 3 but the index is 4.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/Forc.lock
new file mode 100644
index 00000000000..6587bc2240d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/Forc.lock
@@ -0,0 +1,16 @@
+[[package]]
+name = "array_wrong_elements_types"
+source = "member"
+dependencies = [
+    "core",
+    "std",
+]
+
+[[package]]
+name = "core"
+source = "path+from-root-C125AFC4EC59A434"
+
+[[package]]
+name = "std"
+source = "path+from-root-C125AFC4EC59A434"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/Forc.toml
new file mode 100644
index 00000000000..8bbe2f8fe40
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/Forc.toml
@@ -0,0 +1,10 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "array_wrong_elements_types"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
+std = { path = "../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/snapshot.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw
new file mode 100644
index 00000000000..8ed5c3be0af
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw
@@ -0,0 +1,52 @@
+script;
+
+fn vec<T>() -> Vec<T> {
+    Vec::new()
+}
+
+fn main() {
+    // unexpected u16
+    let a: [u8;1] = [1u16];
+
+    // unexpected u16
+    let _ = [1u8, 1u16];
+    let a = [1, 2u8, 3u16, 4u32, 5u64];
+
+    // unexpected u8
+    let _ = [1, 1u16, a[0]];
+
+    // unexpected string slice
+    let _ = [1, "", 1u8, 1u16];
+
+    // unexpected u8
+    let _ = [return, 1u8, 1u16];
+
+    // unexpected u16
+    let _ = [1u8, return, 1u16];
+
+    // unexpected u16
+    let _ = [1, return, 1u8, 1u16];
+
+    // unexpected str
+    let _ = [1, "", 1u16];
+    let _ = [1, 2, "hello"];
+    let _ = [1, return, "", 1u16];
+    let _ = [1, "", return, 1u16];
+
+    // unexpected Vec<u16>
+    let _ = [Vec::new(), vec::<u8>(), vec::<u16>()];
+    
+    // unexpected Option<u8>
+    let a = [None, Some(1), Some(1u8)];
+    let _b: Option<u16> = a[1];
+
+    // unexpected u8
+    let a = [8, 256u16, 8u8];
+    let b: u32 = a[2];
+
+    // Should not warn or error
+    let _ : [u8 ; 0] = [];
+
+    // Literal too big
+    let mut a = [8u8, 8, 18446744073709551615];
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/stdout.snap
new file mode 100644
index 00000000000..bb7fa87aa02
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/stdout.snap
@@ -0,0 +1,308 @@
+---
+source: test/tests/tests.rs
+---
+> forc build --path test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types
+exit status: 1
+output:
+    Building test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types
+   Compiling library core (sway-lib-core)
+   Compiling library std (sway-lib-std)
+   Compiling script array_wrong_elements_types (test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types)
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:41:27
+   |
+39 |     // unexpected Option<u8>
+40 |     let a = [None, Some(1), Some(1u8)];
+41 |     let _b: Option<u16> = a[1];
+   |                           ^^^^ Mismatched types.
+expected: Option<u16>
+found:    Option<u8>.
+help: Variable declaration's type annotation does not match up with the assigned expression's type.
+42 | 
+43 |     // unexpected u8
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:45:18
+   |
+43 |     // unexpected u8
+44 |     let a = [8, 256u16, 8u8];
+45 |     let b: u32 = a[2];
+   |                  ^^^^ Mismatched types.
+expected: u32
+found:    u16.
+help: Variable declaration's type annotation does not match up with the assigned expression's type.
+46 | 
+47 |     // Should not warn or error
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:51:26
+   |
+49 | 
+50 |     // Literal too big
+51 |     let mut a = [8u8, 8, 18446744073709551615];
+   |                          ^^^^^^^^^^^^^^^^^^^^ Literal value is too large for type u8.
+52 | }
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:9:22
+   |
+ 7 | fn main() {
+ 8 |     // unexpected u16
+ 9 |     let a: [u8;1] = [1u16];
+   |                      ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+10 | 
+11 |     // unexpected u16
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:12:19
+   |
+10 | 
+11 |     // unexpected u16
+12 |     let _ = [1u8, 1u16];
+   |                   ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+13 |     let a = [1, 2u8, 3u16, 4u32, 5u64];
+14 | 
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:13:22
+   |
+11 |     // unexpected u16
+12 |     let _ = [1u8, 1u16];
+13 |     let a = [1, 2u8, 3u16, 4u32, 5u64];
+   |                      ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+14 | 
+15 |     // unexpected u8
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:13:28
+   |
+11 |     // unexpected u16
+12 |     let _ = [1u8, 1u16];
+13 |     let a = [1, 2u8, 3u16, 4u32, 5u64];
+   |                            ^^^^ Mismatched types.
+expected: u8
+found:    u32.
+
+14 | 
+15 |     // unexpected u8
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:13:34
+   |
+11 |     // unexpected u16
+12 |     let _ = [1u8, 1u16];
+13 |     let a = [1, 2u8, 3u16, 4u32, 5u64];
+   |                                  ^^^^ Mismatched types.
+expected: u8
+found:    u64.
+
+14 | 
+15 |     // unexpected u8
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:16:23
+   |
+14 | 
+15 |     // unexpected u8
+16 |     let _ = [1, 1u16, a[0]];
+   |                       ^^^^ Mismatched types.
+expected: u16
+found:    u8.
+
+17 | 
+18 |     // unexpected string slice
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:19:17
+   |
+17 | 
+18 |     // unexpected string slice
+19 |     let _ = [1, "", 1u8, 1u16];
+   |                 ^^ Mismatched types.
+expected: u8
+found:    str.
+
+20 | 
+21 |     // unexpected u8
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:19:26
+   |
+17 | 
+18 |     // unexpected string slice
+19 |     let _ = [1, "", 1u8, 1u16];
+   |                          ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+20 | 
+21 |     // unexpected u8
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:22:27
+   |
+20 | 
+21 |     // unexpected u8
+22 |     let _ = [return, 1u8, 1u16];
+   |                           ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+23 | 
+24 |     // unexpected u16
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:25:27
+   |
+23 | 
+24 |     // unexpected u16
+25 |     let _ = [1u8, return, 1u16];
+   |                           ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+26 | 
+27 |     // unexpected u16
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:28:30
+   |
+26 | 
+27 |     // unexpected u16
+28 |     let _ = [1, return, 1u8, 1u16];
+   |                              ^^^^ Mismatched types.
+expected: u8
+found:    u16.
+
+29 | 
+30 |     // unexpected str
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:31:17
+   |
+29 | 
+30 |     // unexpected str
+31 |     let _ = [1, "", 1u16];
+   |                 ^^ Mismatched types.
+expected: u16
+found:    str.
+
+32 |     let _ = [1, 2, "hello"];
+33 |     let _ = [1, return, "", 1u16];
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:32:20
+   |
+30 |     // unexpected str
+31 |     let _ = [1, "", 1u16];
+32 |     let _ = [1, 2, "hello"];
+   |                    ^^^^^^^ Mismatched types.
+expected: numeric
+found:    str.
+
+33 |     let _ = [1, return, "", 1u16];
+34 |     let _ = [1, "", return, 1u16];
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:33:25
+   |
+31 |     let _ = [1, "", 1u16];
+32 |     let _ = [1, 2, "hello"];
+33 |     let _ = [1, return, "", 1u16];
+   |                         ^^ Mismatched types.
+expected: u16
+found:    str.
+
+34 |     let _ = [1, "", return, 1u16];
+35 | 
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:34:17
+   |
+32 |     let _ = [1, 2, "hello"];
+33 |     let _ = [1, return, "", 1u16];
+34 |     let _ = [1, "", return, 1u16];
+   |                 ^^ Mismatched types.
+expected: u16
+found:    str.
+
+35 | 
+36 |     // unexpected Vec<u16>
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:37:39
+   |
+35 | 
+36 |     // unexpected Vec<u16>
+37 |     let _ = [Vec::new(), vec::<u8>(), vec::<u16>()];
+   |                                       ^^^^^^^^^^^^ Mismatched types.
+expected: Vec<u8>
+found:    Vec<u16>.
+
+38 |     
+39 |     // unexpected Option<u8>
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/array_wrong_elements_types/src/main.sw:44:25
+   |
+42 | 
+43 |     // unexpected u8
+44 |     let a = [8, 256u16, 8u8];
+   |                         ^^^ Mismatched types.
+expected: u16
+found:    u8.
+
+45 |     let b: u32 = a[2];
+46 | 
+   |
+____
+
+  Aborting due to 20 errors.
+error: Failed to compile array_wrong_elements_types
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/Forc.lock
new file mode 100644
index 00000000000..ce1b03b30fa
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "asm_unrecognized_opcode"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/Forc.toml
new file mode 100644
index 00000000000..5667453e56f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+implicit-std = false
+name = "asm_unrecognized_opcode"
+entry = "main.sw"
+
+[dependencies]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/src/main.sw
new file mode 100644
index 00000000000..c524244eb9e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/src/main.sw
@@ -0,0 +1,15 @@
+library;
+
+pub fn test() {
+    asm (r1: 0, r2: 0, r3: 0) {
+        blobbb r1 r2 r3;
+    };
+
+    asm (r1: 0, r2: 0, r3: 0) {
+        modd r1 r2 r3;
+    };
+
+    asm (r1: 0, r2: 0, r3: 0) {
+        ttllyunknwn r1 r2 r3;
+    };
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/test.toml
new file mode 100644
index 00000000000..963dd58630e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/asm_unrecognized_opcode/test.toml
@@ -0,0 +1,28 @@
+category = "fail"
+
+#check: $()error
+#sameln: $()Assembly instruction is unknown
+#check: $()blobbb r1 r2 r3;
+#nextln: $()"blobbb" is not a known assembly instruction.
+#nextln: $()Did you mean "blob"?
+
+#check: $()Expected an expression
+
+#check: $()error
+#sameln: $()Assembly instruction is unknown
+#check: $()modd r1 r2 r3;
+#nextln: $()"modd" is not a known assembly instruction.
+#nextln: $()Did you mean "mod" or "modi"?
+
+#check: $()Expected an expression
+
+#check: $()error
+#sameln: $()Assembly instruction is unknown
+#check: $()ttllyunknwn r1 r2 r3;
+#nextln: $()"ttllyunknwn" is not a known assembly instruction.
+
+#check: $()Expected an expression
+
+#not: $()Did you mean
+
+#check: $()6 errors.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/Forc.lock
new file mode 100644
index 00000000000..d6d5627a81d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "associated_type_not_in_trait"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/Forc.toml
similarity index 74%
rename from test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/Forc.toml
index ba104fe3ae6..800719114d2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/Forc.toml
@@ -1,6 +1,6 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
-license = "Apache-2.0"
-name = "impure_read_calls_impure_write"
 entry = "main.sw"
+license = "Apache-2.0"
+name = "associated_type_not_in_trait"
 implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/src/main.sw
new file mode 100644
index 00000000000..5a1f41599ba
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/src/main.sw
@@ -0,0 +1,4 @@
+script;
+trait Trait{}
+struct Struct0{}
+impl Trait for Struct0{type u;const u=0;}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/test.toml
new file mode 100644
index 00000000000..74ffd8a5f62
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/associated_type_not_in_trait/test.toml
@@ -0,0 +1,3 @@
+category = "fail"
+
+# check: $()Type "u" is not a part of trait "Trait"'s interface surface.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/bad_generic_annotation/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/bad_generic_annotation/test.toml
index 2023da0cc3a..e65971dfc6d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/bad_generic_annotation/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/bad_generic_annotation/test.toml
@@ -1,5 +1,11 @@
 category = "fail"
 
+# check: let _g: u32 = three_generics(true, "foo", 10);
+# nextln: $()Mismatched types.
+# nextln: $()expected: u32
+# nextln: $()found:    str.
+# nextln: $()help: Function return type does not match up with local type annotation.
+
 # check: let _g: u32 = three_generics(true, "foo", 10);
 # nextln: $()Mismatched types.
 # nextln: $()expected: u32
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/src/main.sw
index b142db7e44d..30c0c042230 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/src/main.sw
@@ -1,4 +1,4 @@
-script;
+library;
 
 fn main() -> u64 {
     const X;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/test.toml
index 825c088f656..35bf69ce835 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_block_level_no_expr/test.toml
@@ -2,3 +2,5 @@ category = "fail"
 
 # check: $()const X;
 # nextln: $()Constant requires expression.
+
+# check: $()1 error.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.lock
index e1a82f95453..2814fca6639 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.lock
@@ -1,8 +1,3 @@
 [[package]]
 name = "const_eval_bad_struct_with_return"
 source = "member"
-dependencies = ["core"]
-
-[[package]]
-name = "core"
-source = "path+from-root-154BF654D5BA1912"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.toml
index ee771c3e808..02811d183f4 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/Forc.toml
@@ -4,6 +4,3 @@ entry = "main.sw"
 license = "Apache-2.0"
 name = "const_eval_bad_struct_with_return"
 implicit-std = false
-
-[dependencies]
-core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/src/main.sw
index 8d8712ffbd3..940865f0672 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_eval_bad_struct_with_return/src/main.sw
@@ -1,4 +1,4 @@
-script;
+library;
 
 struct MyStruct {
     x: u64
@@ -18,7 +18,3 @@ const B: MyStruct = MyStruct {
         1
     }
 };
-
-fn main() -> u64 {
-    0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/Forc.lock
similarity index 52%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/Forc.lock
index 1e81cf8a690..8926b1a0f1e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/Forc.lock
@@ -1,8 +1,8 @@
 [[package]]
-name = "core"
-source = "path+from-root-F66B05B51B812E20"
-
-[[package]]
-name = "deprecated_attribute"
+name = "const_instead_of_let"
 source = "member"
 dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-9DAB4ED88942C556"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/Forc.toml
new file mode 100644
index 00000000000..59e1cad431a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "const_instead_of_let"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/src/main.sw
similarity index 81%
rename from test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/src/main.sw
rename to test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/src/main.sw
index 4626eaf81c9..ed327ce6488 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/src/main.sw
@@ -12,6 +12,5 @@ pub fn main() {
     let contract_1 = abi(Abi1, b256::min());
     const INVALID_CONST = contract_1.foo();
     let contract_2 = abi(Abi2, INVALID_CONST);
-    let invalid = contract_2.bar();
-    log(invalid);
+    let _ = contract_2.bar();
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/test.toml
similarity index 81%
rename from test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/test.toml
index f6e31892d43..437aba233ee 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_instead_of_let/test.toml
@@ -1,7 +1,6 @@
 category = "fail"
 
 # check: $()error
-# check: const-instead-of-let/src/main.sw:13
 # check: $()const INVALID_CONST = contract_1.foo();
 # nextln: $()Could not evaluate initializer to a const declaration.
 
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/src/main.sw
index eea10258c1c..2bf19b3ff3f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/src/main.sw
@@ -1,7 +1,3 @@
-script;
+library;
 
 const X;
-
-fn main() -> u64 {
-    0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/test.toml
index 825c088f656..35bf69ce835 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/const_top_level_no_expr/test.toml
@@ -2,3 +2,5 @@ category = "fail"
 
 # check: $()const X;
 # nextln: $()Constant requires expression.
+
+# check: $()1 error.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.lock
index 139912752c9..8e713d15485 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
 name = "contract_pure_calls_impure"
 source = "member"
+dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-35CE415E0DBF1633"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.toml
index 1c3209095f4..964d059814d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/Forc.toml
@@ -4,3 +4,6 @@ license = "Apache-2.0"
 name = "contract_pure_calls_impure"
 entry = "main.sw"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/src/main.sw
index d23692d31f5..4e0765dd605 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/src/main.sw
@@ -11,5 +11,7 @@ impl ImpurityTest for Contract {
     }
 }
 
-#[storage(read, write)]
-fn foo() {}
+#[storage(write)]
+fn foo() {
+    let _ = __state_store_word(b256::zero(), 0);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/test.toml
index b1ee853337d..d8d44b4bd1d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/contract_pure_calls_impure/test.toml
@@ -1,4 +1,11 @@
 category = "fail"
 
-# check: foo();
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read, write)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn impure_func() -> bool
+#nextln: $()Function "impure_func" is pure and cannot access storage.
+#check: $()foo();
+#nextln: $()Function "foo" writes to the storage.
+#check: $()Consider declaring the function "impure_func" as `#[storage(write)]`
+
+#check: $()1 error.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/deduplication_of_shadowing_errors/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/deduplication_of_shadowing_errors/test.toml
index 895e150b749..968be6793f5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/deduplication_of_shadowing_errors/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/deduplication_of_shadowing_errors/test.toml
@@ -3,12 +3,12 @@ category = "fail"
 #check: $()error
 #nextln: $()main.sw:7
 #check: $()use lib::Struct;
-#check: $()The imported symbol "Struct" shadows another symbol with the same name.
+#check: $()Imported symbol "Struct" shadows another symbol of the same name.
 
 #check: $()error
 #nextln: $()main.sw:8
 #check: $()use lib::Struct;
-#check: $()The imported symbol "Struct" shadows another symbol with the same name.
+#check: $()Imported symbol "Struct" shadows another symbol of the same name.
 
 #check: $()Constants cannot be shadowed
 #nextln: $()main.sw:13
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/Forc.lock
new file mode 100644
index 00000000000..7edc5e026e0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-62266B0554A16849"
+
+[[package]]
+name = "duplicate_struct_field"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/Forc.toml
new file mode 100644
index 00000000000..9d8c9ab5a22
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+name = "duplicate_struct_field"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/json_abi_oracle.json
new file mode 100644
index 00000000000..c0ff35e67b8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/json_abi_oracle.json
@@ -0,0 +1,35 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "bar",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    },
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "baz",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": [],
+      "type": "()",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/src/main.sw
new file mode 100644
index 00000000000..9692b706999
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+struct S {
+    x: u64,
+}
+
+pub fn main() {
+    let _ = S{
+        x:1,
+        x: "a",
+    };
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/test.toml
new file mode 100644
index 00000000000..b86975dfc6f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/duplicate_struct_field/test.toml
@@ -0,0 +1,4 @@
+category = "fail"
+
+# check: $()Struct field has multiple definitions
+# check: $()Field "x" has multiple definitions.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/Forc.lock
new file mode 100644
index 00000000000..976b79b97d6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "encode_append_wrong_args"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/Forc.toml
new file mode 100644
index 00000000000..080346ed9b0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "encode_append_wrong_args"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_fail/array_oob/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/src/main.sw
new file mode 100644
index 00000000000..b5813db61d8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/src/main.sw
@@ -0,0 +1,17 @@
+library;
+
+pub struct Buffer {
+    buffer: u64
+}
+
+pub trait T {
+    fn ar(buffer: Buffer) -> Buffer;
+}
+
+impl T for str[10] {
+    fn ar(buffer: Buffer) -> Buffer {
+        Buffer {
+            buffer: __encode_buffer_append(buffer.buffer)
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/test.toml
new file mode 100644
index 00000000000..7c6ea4d2bde
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_append_wrong_args/test.toml
@@ -0,0 +1,7 @@
+category = "fail"
+
+# check: $()warning
+# check: $()buffer: __encode_buffer_append(buffer.buffer)
+
+# check: $()buffer: __encode_buffer_append(buffer.buffer)
+# nextln: $()Call to "encode_buffer_append" expects 2 arguments
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/Forc.lock
new file mode 100644
index 00000000000..671b855a7cb
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-BABDDF1B461AF6DA"
+
+[[package]]
+name = "encode_buffer_empty_with_args"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/Forc.toml
new file mode 100644
index 00000000000..377ee70d0ae
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "encode_buffer_empty_with_args"
+entry = "main.sw"
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_fail/array_oob_global_const_index/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/src/main.sw
new file mode 100644
index 00000000000..c54e57c0de2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/src/main.sw
@@ -0,0 +1,13 @@
+library;
+
+struct Buffer {
+    buffer: (raw_ptr, u64, u64),
+}
+
+impl Buffer {
+    pub fn new() -> Self {
+        Buffer {
+            buffer: __encode_buffer_empty(self),
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/test.toml
new file mode 100644
index 00000000000..e51812b07ed
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/encode_buffer_empty_with_args/test.toml
@@ -0,0 +1,4 @@
+category = "fail"
+
+# check: $()buffer: __encode_buffer_empty(self),
+# nextln: $()Call to "encode_buffer_empty" expects 0 arguments
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/Forc.lock
similarity index 56%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/error_const/Forc.lock
index ce884974e55..cc7628fb532 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/Forc.lock
@@ -1,9 +1,9 @@
 [[package]]
 name = "core"
-source = "path+from-root-C27B2C742213E5AD"
+source = "path+from-root-219F2D572E020EEE"
 
 [[package]]
-name = "match_expressions"
+name = "error_const"
 source = "member"
 dependencies = [
     "core",
@@ -12,5 +12,5 @@ dependencies = [
 
 [[package]]
 name = "std"
-source = "path+from-root-C27B2C742213E5AD"
+source = "path+from-root-219F2D572E020EEE"
 dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/Forc.toml
similarity index 87%
rename from test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/error_const/Forc.toml
index da772329ce5..da802cadbf3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/Forc.toml
@@ -2,8 +2,8 @@
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "const-instead-of-let"
+name = "error_const"
 
 [dependencies]
 core = { path = "../../../../../../sway-lib-core" }
-std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
+std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/error_const/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/json_abi_oracle.json
new file mode 100644
index 00000000000..fe51488c706
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/json_abi_oracle.json
@@ -0,0 +1 @@
+[]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/error_const/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/src/main.sw
new file mode 100644
index 00000000000..0daabc68ec7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/src/main.sw
@@ -0,0 +1,3 @@
+library;
+
+const p={/);
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/error_const/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/test.toml
new file mode 100644
index 00000000000..9d1043c6647
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/error_const/test.toml
@@ -0,0 +1,20 @@
+category = "fail"
+
+# check: $()const p={/);
+# nextln: $()Constant "p" should be SCREAMING_SNAKE_CASE.
+
+# check: $()const p={/);
+# nextln: $()This declaration is never used.
+
+# check: $()const p={/);
+# nextln: $()mismatched delimiters
+
+# check: $()const p={/);
+# nextln: $()Expected an expression.
+
+# check: $()const p={/);
+# nextln: $()Could not evaluate initializer to a const declaration.
+
+# check: $()Aborting due to 3 errors.
+
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/Forc.lock
deleted file mode 100644
index 78dab8d06cf..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/Forc.lock
+++ /dev/null
@@ -1,13 +0,0 @@
-[[package]]
-name = "core"
-source = "path+from-root-B089E2A459F9A9B9"
-
-[[package]]
-name = "generic_trait_tuple_without_type_ascription"
-source = "member"
-dependencies = ["std"]
-
-[[package]]
-name = "std"
-source = "path+from-root-B089E2A459F9A9B9"
-dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/src/main.sw
deleted file mode 100644
index 939b3a0c66e..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/src/main.sw
+++ /dev/null
@@ -1,32 +0,0 @@
-script;
-
-pub trait MyFrom<T> {
-    fn from(b: T) -> Self;
-}
-
-
-pub trait MyInto<T> {
-    fn my_into(self) -> T;
-}
-
-
-impl<T, U> MyInto<U> for T
-where
-    U: MyFrom<T>,
-{
-    fn my_into(self) -> U {
-        U::from(self)
-    }
-}
-
-impl MyFrom<u256> for (u64, u64, u64, u64) {
-    fn from(_val: u256) -> (u64, u64, u64, u64) {
-        (42, 0, 0, 0)
-    }
-}
-
-fn main() -> bool {
-    let (_a, _b, _c, _d) = u256::min().my_into();
-
-    true
-}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/test.toml
deleted file mode 100644
index 9223a110521..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/test.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-category = "fail"
-
-# check: $()let (_a, _b, _c, _d) = u256::min().my_into();
-# nextln: $()Trait "MyFrom<u256>" is not implemented for type "(_, _, _, _)".
-
-# check: $()let (_a, _b, _c, _d) = u256::min().my_into();
-# nextln: $()Cannot infer type for type parameter "_". Insufficient type information provided. Try annotating its type.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/Forc.lock
new file mode 100644
index 00000000000..3cb45ccbaed
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-7EB1B3610F4F66A3"
+
+[[package]]
+name = "impl_self_duplicated"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/Forc.toml
new file mode 100644
index 00000000000..7bd047f83cf
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+implicit-std = false
+license = "Apache-2.0"
+name = "impl_self_duplicated"
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/src/main.sw
new file mode 100644
index 00000000000..b51479e89e7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/src/main.sw
@@ -0,0 +1,42 @@
+script;
+trait Cat {
+ fn speak(self) -> u64;
+}
+trait Dog {
+ fn speak(self) -> u64;
+}
+struct S<T> {
+ x: T,
+}
+impl<T> S<T>
+where
+ T: Cat,
+{
+ fn foo(self) -> u64 {
+ self.x.speak() + 1
+ }
+}
+impl<T> S<T>
+where
+ T: Dog,
+{
+ fn foo(self) -> u64 {
+ self.x.speak() + 2
+ }
+}
+impl Dog for u64 {
+ fn speak(self) -> u64 {
+ 2
+ }
+}
+impl Cat for u64 {
+ fn speak(self) -> u64 {
+ 1
+ }
+}
+fn main() -> u64 {
+ let s = S::<u64> { x: 1 };
+ s.foo();
+
+ 42
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/test.toml
new file mode 100644
index 00000000000..716219cfde9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impl_self_duplicated/test.toml
@@ -0,0 +1,6 @@
+category = "fail"
+validate_abi = false
+expected_warnings = 3
+
+# check: fn foo(self) -> u64 {
+# nextln: $()Duplicate definitions for the method "foo" for type "S<T>".
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/Forc.lock
new file mode 100644
index 00000000000..418848eceb5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-3F7C73944D096B89"
+
+[[package]]
+name = "implicit_trait_constraint"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/Forc.toml
new file mode 100644
index 00000000000..033423a1fdd
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+implicit-std = false
+license = "Apache-2.0"
+name = "implicit_trait_constraint"
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/src/main.sw
new file mode 100644
index 00000000000..15df85fe89b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/src/main.sw
@@ -0,0 +1,32 @@
+script;
+trait T2 {}
+trait T1: T2 {
+    fn new() -> Self;
+}
+
+struct S {}
+impl T2 for S {}
+impl T1 for S {
+    fn new() -> Self {
+        S {}
+    }
+}
+
+fn bar<T>() -> T
+where
+ T: T1,
+{
+    T::new()
+}
+
+fn foo<T>() -> T
+where
+ T: T2,
+{
+    bar()
+}
+
+fn main() -> u64 {
+    let _:S = foo();
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/test.toml
new file mode 100644
index 00000000000..b91b74218e6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/implicit_trait_constraint/test.toml
@@ -0,0 +1,4 @@
+category = "fail"
+
+# check: $()bar()
+# nextln: $()Trait "T1" is not implemented for type "T".
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.lock
index 3a21fac4e30..377ae4a89f8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
-name = 'impure_abi_read_calls_impure_write'
-source = 'member'
+name = "core"
+source = "path+from-root-1FE39E672D7A7D13"
+
+[[package]]
+name = "impure_abi_read_calls_impure_write"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.toml
index 74421825e53..61394d53f8f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/Forc.toml
@@ -4,3 +4,6 @@ authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/src/main.sw
index 3ae3b741955..358f2940515 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/src/main.sw
@@ -14,5 +14,6 @@ impl MyContract for Contract {
 
 #[storage(write)]
 fn f() -> bool {
+    let _ = __state_store_word(b256::zero(), 0);
     true
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/test.toml
index b6888964bb9..55884b2bde2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_abi_read_calls_impure_write/test.toml
@@ -1,5 +1,11 @@
 category = "fail"
 
-# check: fn test_function() -> bool {
-# check: f()
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read, write)]" to the function declaration.
+#check: $()error
+#sameln: $()Storage read-only function cannot write to storage
+#check: $()fn test_function() -> bool
+#nextln: $()Function "test_function" is declared as `#[storage(read)]` and cannot write to storage.
+#check: $()f()
+#nextln: $()Function "f" writes to the storage.
+#check: $()Consider declaring the function "test_function" as `#[storage(read, write)]`
+
+#check: $()1 error.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/Forc.lock
deleted file mode 100644
index 3f79475f867..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/Forc.lock
+++ /dev/null
@@ -1,3 +0,0 @@
-[[package]]
-name = 'impure_read_calls_impure_write'
-source = 'member'
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/src/main.sw
deleted file mode 100644
index c2cc8febb22..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/src/main.sw
+++ /dev/null
@@ -1,12 +0,0 @@
-contract;
-
-fn main() {
-}
-
-#[storage(read)]
-fn can_read() {
-  can_write();
-}
-
-#[storage(write)]
-fn can_write() {}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/test.toml
deleted file mode 100644
index 2c13c211b9b..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_read_calls_impure_write/test.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-category = "fail"
-
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read, write)]" to the function declaration.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.lock
index b209a503e5f..2549f45d2cb 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
-name = 'impure_trait_read_calls_impure_write'
-source = 'member'
+name = "core"
+source = "path+from-root-DA75D6DB25B7E1EA"
+
+[[package]]
+name = "impure_trait_read_calls_impure_write"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.toml
index 5681bb22946..be0354fefb5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/Forc.toml
@@ -4,3 +4,6 @@ authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/src/main.sw
index af8f5caba34..0e391395045 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/src/main.sw
@@ -8,7 +8,20 @@ trait A {
 impl A for bool {
     #[storage(write)]
     fn f(self) -> bool {
-        self
+        let _ = __state_store_word(b256::zero(), 0);
+        true
+    }
+}
+
+abi Abi {
+    #[storage(read, write)]
+    fn test() -> bool;
+}
+
+impl Abi for Contract {
+    #[storage(read, write)]
+    fn test() -> bool {
+        g()
     }
 }
 
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/test.toml
index 59172c85dfc..ae1396a8f82 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/impure_trait_read_calls_impure_write/test.toml
@@ -1,5 +1,11 @@
 category = "fail"
 
-# check: pub fn g() -> bool {
-# nextln: true.f()
-# nextln: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read, write)]" to the function declaration.
+#check: $()error
+#sameln: $()Storage read-only function cannot write to storage
+#check: $()pub fn g() -> bool
+#nextln: $()Function "g" is declared as `#[storage(read)]` and cannot write to storage.
+#check: $()true.f()
+#nextln: $()Function "f" writes to the storage.
+#check: $()Consider declaring the function "g" as `#[storage(read, write)]`
+
+#check: 1 error.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/insufficient_type_info/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/insufficient_type_info/test.toml
index 04cf3e244a3..27dfeaece54 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/insufficient_type_info/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/insufficient_type_info/test.toml
@@ -8,6 +8,10 @@ category = "fail"
 # check: $()None::<T>;
 # nextln: $()Could not find symbol "T" in this scope.
 
+# check: $()error
+# check: $()None::<T>;
+# nextln: $()Unknown type name "T"
+
 # check: $()error
 # check: $()foo()
 # nextln: $()Cannot infer type for type parameter "T". Insufficient type information provided. Try annotating its type.
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/Forc.lock
similarity index 54%
rename from test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/Forc.lock
index e2e3889edf9..1cef6b3f7a1 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/Forc.lock
@@ -1,3 +1,3 @@
 [[package]]
-name = "midenvm_trivial"
+name = "invalid_cfg_arg"
 source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/Forc.toml
similarity index 80%
rename from test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/Forc.toml
index 65b425cdf2e..582fa8b5e47 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/Forc.toml
@@ -1,6 +1,6 @@
 [project]
+name = "invalid_cfg_arg"
 authors = ["Fuel Labs <contact@fuel.sh>"]
-license = "Apache-2.0"
-name = "pure_calls_impure"
 entry = "main.sw"
+license = "Apache-2.0"
 implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/src/main.sw
new file mode 100644
index 00000000000..c9ad0835d76
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/src/main.sw
@@ -0,0 +1,2 @@
+predicate;
+#[cfg(c)] a
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/test.toml
new file mode 100644
index 00000000000..1f48bdf0556
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/invalid_cfg_arg/test.toml
@@ -0,0 +1,10 @@
+category = "fail"
+
+# check: $()#[cfg(c)] a
+# nextln: $()Unexpected attribute value: "c" for attribute: "cfg" expected value "target" or "program_type" or "experimental_new_encoding"
+
+# check: $()#[cfg(c)] a
+# nextln: $()Expected an item.
+
+# check: $()#[cfg(c)] a
+# nextln: $()Unexpected attribute value: "c" for attribute: "cfg"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/Forc.lock
old mode 100644
new mode 100755
similarity index 55%
rename from test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/Forc.lock
index 196dae73163..2f79b915015
--- a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/Forc.lock
@@ -1,13 +1,13 @@
 [[package]]
-name = "core"
-source = "path+from-root-A2C6CB9CD0980A06"
-
-[[package]]
-name = "log_decode"
+name = "aliases"
 source = "member"
 dependencies = ["std"]
 
+[[package]]
+name = "core"
+source = "path+from-root-D05BA88A39195D06"
+
 [[package]]
 name = "std"
-source = "path+from-root-A2C6CB9CD0980A06"
+source = "path+from-root-D05BA88A39195D06"
 dependencies = ["core"]
diff --git a/forc-plugins/forc-client/test/data/standalone_contract_b/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/Forc.toml
old mode 100644
new mode 100755
similarity index 59%
rename from forc-plugins/forc-client/test/data/standalone_contract_b/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/Forc.toml
index ccca650f3d5..5e3bdd0c704
--- a/forc-plugins/forc-client/test/data/standalone_contract_b/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/Forc.toml
@@ -1,9 +1,9 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "aliases"
 entry = "main.sw"
 implicit-std = false
-license = "Apache-2.0"
-name = "standalone_contract_b"
 
 [dependencies]
-std = { path = "../../../../../../../../sway-lib-std/" }
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/json_abi_oracle_new_encoding.json
old mode 100644
new mode 100755
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/json_abi_oracle_new_encoding.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/json_abi_oracle_new_encoding.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_2.sw
new file mode 100755
index 00000000000..1fa9465b0ec
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub enum Items2_Variants {
+    Z: u64,
+    W: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_3.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_3.sw
new file mode 100755
index 00000000000..c836a3b99dd
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_3.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items3_Struct {
+    pub c: u64,
+}
+
+pub enum Items3_Enum {
+    E: u64,
+    F: u64,
+}
+
+pub enum Items3_Variants {
+    U: u64,
+    V: u64,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 3872;
+
+pub fn items_3_function() -> u64 {
+    ITEMS_3_FUNCTION_RES
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_4.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_4.sw
new file mode 100755
index 00000000000..5c297e872ab
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_4.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: u64,
+}
+
+pub enum Items4_Enum {
+    G: u64,
+    H: u64,
+}
+
+pub enum Items4_Variants {
+    S: u64,
+    T: u64,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 14278;
+
+pub fn items_4_function() -> u64 {
+    ITEMS_4_FUNCTION_RES
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_5.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_5.sw
new file mode 100755
index 00000000000..72f5360035e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/items_5.sw
@@ -0,0 +1,5 @@
+library;
+
+pub trait Items5Trait<T> {
+    fn items_5_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_1.sw
new file mode 100644
index 00000000000..d40aca7a5f1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct as Alias1_Struct;
+
+pub use ::items_1::Items1_Enum as Alias1_Enum;
+
+pub use ::items_1::Items1_Variants::X as Alias1_X;
+pub use ::items_1::Items1_Variants::Y as Alias1_Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES as ALIAS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function as alias_1_function;
+
+pub use ::items_1::Items1Trait as Alias1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_2.sw
new file mode 100644
index 00000000000..26b2411e634
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_2::Items2_Struct as Alias2_Struct;
+
+pub use ::items_2::Items2_Enum as Alias2_Enum;
+
+pub use ::items_2::Items2_Variants::Z as Alias2_Z;
+pub use ::items_2::Items2_Variants::W as Alias2_W;
+
+pub use ::items_2::ITEMS_2_FUNCTION_RES as ALIAS_2_FUNCTION_RES;
+
+pub use ::items_2::items_2_function as alias_2_function;
+
+pub use ::items_2::Items2Trait as Alias2Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_3.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_3.sw
new file mode 100644
index 00000000000..9476211085e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_3.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_3::Items3_Struct as Alias3_Struct;
+
+pub use ::items_3::Items3_Enum as Alias3_Enum;
+
+pub use ::items_3::Items3_Variants::U as Alias3_U;
+pub use ::items_3::Items3_Variants::V as Alias3_V;
+
+pub use ::items_3::ITEMS_3_FUNCTION_RES as ALIAS_3_FUNCTION_RES;
+
+pub use ::items_3::items_3_function as alias_3_function;
+
+pub use ::items_3::Items3Trait as Alias3Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_4_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_4_1.sw
new file mode 100644
index 00000000000..6817b4e8aa5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_4_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_4::Items4_Struct as Alias4_Struct;
+
+pub use ::items_4::Items4_Enum as Alias4_Enum;
+
+pub use ::items_4::Items4_Variants::S as Alias4_S;
+pub use ::items_4::Items4_Variants::T as Alias4_T;
+
+pub use ::items_4::ITEMS_4_FUNCTION_RES as ALIAS_4_FUNCTION_RES;
+
+pub use ::items_4::items_4_function as alias_4_function;
+
+pub use ::items_4::Items4Trait as Alias4Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_4_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_4_2.sw
new file mode 100644
index 00000000000..229326aba37
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_4_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::lib_4_1::Alias4_Struct as AltAlias4_Struct;
+
+pub use ::lib_4_1::Alias4_Enum as AltAlias4_Enum;
+
+pub use ::lib_4_1::Alias4_S as AltAlias4_S;
+pub use ::lib_4_1::Alias4_T as AltAlias4_T;
+
+pub use ::lib_4_1::ALIAS_4_FUNCTION_RES as ALTALIAS_4_FUNCTION_RES;
+
+pub use ::lib_4_1::alias_4_function as altalias_4_function;
+
+pub use ::lib_4_1::Alias4Trait as AltAlias4Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_5_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_5_1.sw
new file mode 100644
index 00000000000..fdb5c12af94
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_5_1.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use ::items_5::Items5Trait as Alias5Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_5_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_5_2.sw
new file mode 100644
index 00000000000..e2206b6136b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/lib_5_2.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use ::items_5::Items5Trait as AltAlias5Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/main.sw
new file mode 100755
index 00000000000..d84157a1bce
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/main.sw
@@ -0,0 +1,20 @@
+script;
+
+mod items_1;
+mod lib_1;  // Aliased item reexports of items_1
+mod items_2;
+mod lib_2;  // Aliased item reexports of items_2
+mod items_3;
+mod lib_3;  // Aliased item reexports of items_3
+mod items_4;
+mod lib_4_1;  // Aliased item reexports of items_4
+mod lib_4_2;  // Aliased item reexports of lib_4_1
+mod items_5;
+mod lib_5_1;  // Aliased trait reexports from items_5
+mod lib_5_2;  // Aliased trait reexports from items_5
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/tests.sw
new file mode 100644
index 00000000000..a89efa89d2e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/src/tests.sw
@@ -0,0 +1,184 @@
+library;
+
+// Reexported items from items_1.sw. All reexports aliased by lib_1
+use ::lib_1::Items1_Struct;
+use ::lib_1::Items1_Enum;
+use ::lib_1::Items1_X;
+use ::lib_1::Items1_Y;
+use ::lib_1::ITEMS_1_FUNCTION_RES;
+use ::lib_1::items_1_function;
+use ::lib_1::Items1Trait;
+
+use ::items_1::Items1_Variants;
+
+// Reexported items from items_2.sw. All reexports aliased by lib_2
+use ::lib_2::Alias2_Struct;
+use ::lib_2::Alias2_Enum;
+use ::lib_2::Alias2_Z;
+use ::lib_2::Alias2_W;
+use ::lib_2::ALIAS_2_FUNCTION_RES;
+use ::lib_2::alias_2_function;
+use ::lib_2::Alias2Trait;
+
+use ::items_2::Items2_Variants;
+
+// Reexported items from items_3.sw. All reexports aliased by lib_3
+use ::lib_3::*;
+
+use ::items_3::Items3_Variants;
+
+// Reexported items from items_4.sw. All reexports aliased by lib_4_1 and realiased by lib_4_2
+use ::lib_4_2::Alias4_Struct;
+use ::lib_4_2::Alias4_Enum;
+use ::lib_4_2::Alias4_S;
+use ::lib_4_2::Alias4_T;
+use ::lib_4_2::ALIAS_4_FUNCTION_RES;
+use ::lib_4_2::alias_4_function;
+use ::lib_4_2::Alias4Trait;
+
+// Reexported trait from items_5.sw. Aliased both by lib_5_1 and by lib_5_2
+use ::lib_5_1::*;
+use ::lib_5_2::*;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::A(val) => val,
+	Items2_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	Items2_X(val) => val,
+	Items2_Y(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_3 tests
+
+fn project_items_3_struct(input: Items3_Struct) -> u64 {
+    input.c
+}
+
+fn project_items_3_enum(input: Items3_Enum) -> u64 {
+    match input {
+	Items3_Enum::E(val) => val,
+	Items3_Enum::F(val) => val + 1000,
+    }
+}
+
+fn project_items_3_variants(input: Items3_Variants) -> u64 {
+    match input {
+	Items3_U(val) => val,
+	Items3_V(val) => val + 1000,
+    }
+}
+
+fn call_items_3_function() -> u64 {
+    items_3_function()
+}
+
+impl Items3Trait<TestStruct2> for TestStruct1 {
+    fn items_3_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+// lib_5 tests
+
+// Alias5Trait and AltAlias5Trait refer to the same trait, but no error is reported for multiple
+// impls of same trait for same type.
+impl Alias5Trait<TestStruct2> for TestStruct1 {
+    fn items_5_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+impl AltAlias5Trait<TestStruct2> for TestStruct1 {
+    fn items_5_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_2_struct = Items2_Struct { b: 123 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 123);
+
+    let items_2_enum = Items2_Enum::C(432);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 432);
+
+    let items_2_variants = Z(680);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 680);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+
+    let items_3_struct = Items3_Struct { c: 123 };
+    let items_3_struct_res = project_items_3_struct(items_3_struct);
+    assert(items_3_struct_res == 123);
+
+    let items_3_enum = Items3_Enum::E(432);
+    let items_3_enum_res = project_items_3_enum(items_3_enum);
+    assert(items_3_enum_res == 432);
+
+    let items_3_variants = U(680);
+    let items_3_variants_res = project_items_3_variants(items_3_variants);
+    assert(items_3_variants_res == 680);
+
+    let items_3_function_res = call_items_3_function();
+    assert(items_3_function_res == ITEMS_3_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+    assert(items_3_trait_teststruct_1_res);
+
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_5_trait_teststruct_1_res = teststruct_1.items_5_trait_function(teststruct_2);
+    assert(items_5_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/test.toml
new file mode 100755
index 00000000000..8d07f8ae8dc
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/aliases/test.toml
@@ -0,0 +1,188 @@
+category = "fail"
+
+#check: $()error
+#check: $()use ::lib_1::Items1_Struct;
+#nextln: $()Could not find symbol "Items1_Struct" in this scope.
+
+#check: $()error
+#check: $()use ::lib_1::Items1_Enum;
+#nextln: $()Could not find symbol "Items1_Enum" in this scope.
+
+#check: $()error
+#check: $()use ::lib_1::Items1_X;
+#nextln: $()Could not find symbol "Items1_X" in this scope.
+
+#check: $()error
+#check: $()use ::lib_1::Items1_Y;
+#nextln: $()Could not find symbol "Items1_Y" in this scope.
+
+#check: $()error
+#check: $()use ::lib_1::ITEMS_1_FUNCTION_RES;
+#nextln: $()Could not find symbol "ITEMS_1_FUNCTION_RES" in this scope.
+
+#check: $()error
+#check: $()use ::lib_1::items_1_function;
+#nextln: $()Could not find symbol "items_1_function" in this scope.
+
+#check: $()error
+#check: $()use ::lib_1::Items1Trait;
+#nextln: $()Could not find symbol "Items1Trait" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::Alias4_Struct;
+#nextln: $()Could not find symbol "Alias4_Struct" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::Alias4_Enum;
+#nextln: $()Could not find symbol "Alias4_Enum" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::Alias4_S;
+#nextln: $()Could not find symbol "Alias4_S" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::Alias4_T;
+#nextln: $()Could not find symbol "Alias4_T" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::ALIAS_4_FUNCTION_RES;
+#nextln: $()Could not find symbol "ALIAS_4_FUNCTION_RES" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::alias_4_function;
+#nextln: $()Could not find symbol "alias_4_function" in this scope.
+
+#check: $()error
+#check: $()use ::lib_4_2::Alias4Trait;
+#nextln: $()Could not find symbol "Alias4Trait" in this scope.
+
+#check: $()error
+#check: $()fn project_items_2_struct(input: Items2_Struct) -> u64 {
+#nextln: $()Could not find symbol "Items2_Struct" in this scope.
+
+#check: $()error
+#check: $()fn project_items_2_struct(input: Items2_Struct) -> u64 {
+#nextln: $()Unknown type name "Items2_Struct".
+
+#check: $()error
+#check: $()fn project_items_2_enum(input: Items2_Enum) -> u64 {
+#nextln: $()Could not find symbol "Items2_Enum" in this scope.
+
+#check: $()error
+#check: $()fn project_items_2_enum(input: Items2_Enum) -> u64 {
+#nextln: $()Unknown type name "Items2_Enum".
+
+#check: $()error
+#check: $()Items2_X(val) => val,
+#nextln: $()Could not find symbol "Items2_X" in this scope.
+
+#check: $()error
+#check: $()Items2_Y(val) => val + 1000,
+#nextln: $()Could not find symbol "Items2_Y" in this scope.
+
+#check: $()error
+#check: $()fn call_items_2_function() -> u64 {
+#nextln: $()items_2_function()
+#nextln: $()Could not find symbol "items_2_function" in this scope.
+
+#check: $()error
+#check: $()impl Items2Trait<TestStruct2> for TestStruct1 {
+#nextln: $()Could not find symbol "Items2Trait" in this scope.
+
+#check: $()error
+#check: $()impl Items2Trait<TestStruct2> for TestStruct1 {
+#nextln: $()Trait "Items2Trait" cannot be found in the current scope.
+
+#check: $()error
+#check: $()let items_2_struct = Items2_Struct { b: 123 };
+#nextln: $()Could not find symbol "Items2_Struct" in this scope.
+
+#check: $()error
+#check: $()let items_2_struct = Items2_Struct { b: 123 };
+#nextln: $()Unknown type name "Items2_Struct".
+
+#check: $()error
+#check: $()let items_2_struct_res = project_items_2_struct(items_2_struct);
+#nextln: $()Could not find symbol "project_items_2_struct" in this scope.
+
+#check: $()error
+#check: $()assert(items_2_struct_res == 123);
+#nextln: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()let items_2_enum = Items2_Enum::C(432);
+#nextln: $()Could not find symbol "Items2_Enum" in this scope.
+
+#check: $()error
+#check: $()let items_2_enum = Items2_Enum::C(432);
+#nextln: $()Unknown type name "Items2_Enum".
+
+#check: $()error
+#check: $()let items_2_enum_res = project_items_2_enum(items_2_enum);
+#nextln: $()Could not find symbol "project_items_2_enum" in this scope.
+
+#check: $()error
+#check: $()assert(items_2_enum_res == 432);
+#nextln: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()let items_2_variants = Z(680);
+#nextln: $()Could not find symbol "Z" in this scope.
+
+#check: $()error
+#check: $()assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+#nextln: $()Variable "ITEMS_2_FUNCTION_RES" does not exist in this scope.
+
+#check: $()error
+#check: $()let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+#nextln: $()No method named "items_2_trait_function" found for type "TestStruct1".
+
+#check: $()error
+#check: $()let items_3_struct = Items3_Struct { c: 123 };
+#nextln: $()Could not find symbol "Items3_Struct" in this scope.
+
+#check: $()error
+#check: $()let items_3_struct = Items3_Struct { c: 123 };
+#nextln: $()Unknown type name "Items3_Struct".
+
+#check: $()error
+#check: $()let items_3_struct_res = project_items_3_struct(items_3_struct);
+#nextln: $()Could not find symbol "project_items_3_struct" in this scope.
+
+#check: $()error
+#check: $()assert(items_3_struct_res == 123);
+#nextln: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()let items_3_enum = Items3_Enum::E(432);
+#nextln: $()Could not find symbol "Items3_Enum" in this scope.
+
+#check: $()error
+#check: $()let items_3_enum = Items3_Enum::E(432);
+#nextln: $()Unknown type name "Items3_Enum".
+
+#check: $()error
+#check: $()let items_3_enum_res = project_items_3_enum(items_3_enum);
+#nextln: $()Could not find symbol "project_items_3_enum" in this scope.
+
+#check: $()error
+#check: $()assert(items_3_enum_res == 432);
+#nextln: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()let items_3_variants = U(680);
+#nextln: $()Could not find symbol "U" in this scope.
+
+#check: $()error
+#check: $()assert(items_3_function_res == ITEMS_3_FUNCTION_RES);
+#nextln: $()Variable "ITEMS_3_FUNCTION_RES" does not exist in this scope.
+
+#check: $()error
+#check: $()let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+#nextln: $()No method named "items_3_trait_function" found for type "TestStruct1".
+
+#check: $()error
+#check: $()let items_5_trait_teststruct_1_res = teststruct_1.items_5_trait_function(teststruct_2);
+#nextln: $()Multiple applicable items in scope.
+
+#check: $()Aborting due to 55 errors.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/Forc.lock
new file mode 100755
index 00000000000..d59e66c3300
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-5E33A7D67412F1BB"
+
+[[package]]
+name = "multiple_imports_of_same_reexport"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-5E33A7D67412F1BB"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/Forc.toml
new file mode 100755
index 00000000000..06785d8428a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "multiple_imports_of_same_reexport"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle_new_encoding.json
old mode 100644
new mode 100755
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/json_abi_oracle_new_encoding.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle_new_encoding.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/lib_1_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/lib_1_1.sw
new file mode 100644
index 00000000000..9d3a4594442
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/lib_1_1.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ::items_1::*;
+pub use ::items_1::Items1_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/lib_1_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/lib_1_2.sw
new file mode 100644
index 00000000000..9d3a4594442
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/lib_1_2.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ::items_1::*;
+pub use ::items_1::Items1_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/main.sw
new file mode 100755
index 00000000000..c4f06aaf84f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/main.sw
@@ -0,0 +1,11 @@
+script;
+
+mod items_1;
+mod lib_1_1;  // Item reexports of items_1
+mod lib_1_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/tests.sw
new file mode 100644
index 00000000000..dc263b07cf5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/src/tests.sw
@@ -0,0 +1,88 @@
+library;
+
+// Both lib_1_1.sw and lib_1_2.sw reexport items from items_1.sw. All reexports are star imports.
+// Importing individual items from both lib_1_1 and lib_1_2 causes a name clash.
+// (The fact that they refer to the same item is irrelevant, since it is also an error to import the
+// same item twice from the same source)
+use ::lib_1_1::Items1_Struct; 
+use ::lib_1_1::Items1_Enum;
+use ::lib_1_1::Items1_Variants::X; 
+use ::lib_1_1::Items1_Variants::Y; 
+use ::lib_1_1::ITEMS_1_FUNCTION_RES; 
+use ::lib_1_1::items_1_function; 
+use ::lib_1_1::Items1Trait;
+
+use ::lib_1_2::Items1_Struct;
+use ::lib_1_2::Items1_Enum;
+use ::lib_1_2::Items1_Variants::X;
+use ::lib_1_2::Items1_Variants::Y;
+use ::lib_1_2::ITEMS_1_FUNCTION_RES;
+use ::lib_1_2::items_1_function;
+use ::lib_1_2::Items1Trait;
+
+use ::items_1::Items1_Variants;
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+// items_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/test.toml
new file mode 100755
index 00000000000..34426f29662
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/multiple_imports_of_same_reexport/test.toml
@@ -0,0 +1,31 @@
+category = "fail"
+
+#check: $()error
+#check: $()use ::lib_1_2::Items1_Struct;
+#nextln: $()Imported symbol "Items1_Struct" shadows another symbol of the same name.
+
+#check: $()error
+#check: $()use ::lib_1_2::Items1_Enum;
+#nextln: $()Imported symbol "Items1_Enum" shadows another symbol of the same name.
+
+#check: $()error
+#check: $()use ::lib_1_2::Items1_Variants::X;
+#nextln: $()Imported symbol "X" shadows another symbol of the same name.
+
+#check: $()error
+#check: $()use ::lib_1_2::Items1_Variants::Y;
+#nextln: $()Imported symbol "Y" shadows another symbol of the same name.
+
+#check: $()error
+#check: $()use ::lib_1_2::ITEMS_1_FUNCTION_RES;
+#nextln: $()Imported symbol "ITEMS_1_FUNCTION_RES" shadows another symbol of the same name.
+
+#check: $()error	 
+#check: $()use ::lib_1_2::items_1_function;
+#nextln: $()Imported symbol "items_1_function" shadows another symbol of the same name.
+
+#check: $()error
+#check: $()use ::lib_1_2::Items1Trait;
+#nextln: $()Imported symbol "Items1Trait" shadows another symbol of the same name.
+
+#check: $()Aborting due to 7 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/Forc.lock
new file mode 100755
index 00000000000..ac25cb26c8e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-EE202EE2D1735C08"
+
+[[package]]
+name = "shadowing_in_reexporting_module"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-EE202EE2D1735C08"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/Forc.toml
new file mode 100755
index 00000000000..4b87dd678a8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "shadowing_in_reexporting_module"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/json_abi_oracle_new_encoding.json
old mode 100644
new mode 100755
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/json_abi_oracle_new_encoding.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/json_abi_oracle_new_encoding.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_1.sw
new file mode 100644
index 00000000000..95b236919b7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_1.sw
@@ -0,0 +1,20 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: bool,
+}
+
+pub enum Items1_Enum {
+    A: bool,
+    B: bool,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> bool {
+    ITEMS_1_FUNCTION_RES == 456
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_2_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_2_1.sw
new file mode 100644
index 00000000000..f00aa5f00c7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_2_1.sw
@@ -0,0 +1,20 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: bool,
+}
+
+pub enum Items2_Enum {
+    C: bool,
+    D: bool,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 789;
+
+pub fn items_2_function() -> bool {
+    ITEMS_2_FUNCTION_RES == 789
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_2_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_2_2.sw
new file mode 100644
index 00000000000..6822e86d865
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_2_2.sw
@@ -0,0 +1,20 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_3_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_3_1.sw
new file mode 100644
index 00000000000..86138d9e3ed
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_3_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items3_Struct {
+    pub c: bool,
+}
+
+pub enum Items3_Enum {
+    E: bool,
+    F: bool,
+}
+
+pub enum Items3_Variants {
+    G: bool,
+    H: bool,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 1234;
+
+pub fn items_3_function() -> bool {
+    ITEMS_3_FUNCTION_RES == 1234
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_1.sw
new file mode 100644
index 00000000000..2d9be57fc13
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: bool,
+}
+
+pub enum Items4_Enum {
+    I: bool,
+    J: bool,
+}
+
+pub enum Items4_Variants {
+    K: bool,
+    L: bool,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 5678;
+
+pub fn items_4_function() -> bool {
+    ITEMS_4_FUNCTION_RES == 5678
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_2.sw
new file mode 100644
index 00000000000..d57d5b3fbc6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: u64,
+}
+
+pub enum Items4_Enum {
+    I: u64,
+    J: u64,
+}
+
+pub enum Items4_Variants {
+    K: u64,
+    L: u64,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 8765;
+
+pub fn items_4_function() -> u64 {
+    ITEMS_4_FUNCTION_RES
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_3.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_3.sw
new file mode 100644
index 00000000000..92293307319
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_3.sw
@@ -0,0 +1,6 @@
+library;
+
+pub enum Items4_Variants2 {
+    M: bool,
+    N: bool,
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_4.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_4.sw
new file mode 100644
index 00000000000..2f9d86748af
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/items_4_4.sw
@@ -0,0 +1,6 @@
+library;
+
+pub enum Items4_Variants2 {
+    M: u64,
+    N: u64,
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_1.sw
new file mode 100644
index 00000000000..783403a1e47
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_1.sw
@@ -0,0 +1,22 @@
+library;
+
+pub use ::items_1::*;
+
+struct Items1_Struct {
+    a: u64,
+}
+
+enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+const ITEMS_1_FUNCTION_RES = 654;
+
+fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_2.sw
new file mode 100644
index 00000000000..a249d995c9d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_2.sw
@@ -0,0 +1,9 @@
+library;
+
+pub use ::items_2_1::*;
+
+use ::items_2_2::Items2_Struct;
+use ::items_2_2::Items2_Enum;
+use ::items_2_2::ITEMS_2_FUNCTION_RES;
+use ::items_2_2::items_2_function;
+use ::items_2_2::Items2Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_3.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_3.sw
new file mode 100644
index 00000000000..6ed081d11ef
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_3.sw
@@ -0,0 +1,28 @@
+library;
+
+pub use ::items_3_1::*;
+pub use ::items_3_1::Items3_Variants::*;
+
+struct Items3_Struct {
+    pub c: u64,
+}
+
+enum Items3_Enum {
+    E: u64,
+    F: u64,
+}
+
+enum Items3_Variants {
+    G: u64,
+    H: u64,
+}
+
+const ITEMS_3_FUNCTION_RES = 4321;
+
+fn items_3_function() -> u64 {
+    ITEMS_3_FUNCTION_RES
+}
+
+trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_4.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_4.sw
new file mode 100644
index 00000000000..df9383b3da2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/lib_4.sw
@@ -0,0 +1,17 @@
+library;
+
+pub use ::items_4_1::*;
+pub use ::items_4_1::Items4_Variants::*;
+
+use ::items_4_2::Items4_Struct;
+use ::items_4_2::Items4_Enum;
+use ::items_4_2::Items4_Variants;
+use ::items_4_2::Items4_Variants::K;
+use ::items_4_2::Items4_Variants::L;
+use ::items_4_2::ITEMS_4_FUNCTION_RES;
+use ::items_4_2::items_4_function;
+use ::items_4_2::Items4Trait;
+
+pub use ::items_4_3::Items4_Variants2::*;
+use ::items_4_4::Items4_Variants2::M;
+use ::items_4_4::Items4_Variants2::N;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/main.sw
new file mode 100755
index 00000000000..a2961173628
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/main.sw
@@ -0,0 +1,20 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2_1;
+mod items_2_2;
+mod lib_2;  // Item reexports of items_2_1 and items_2_2
+mod items_3_1;
+mod lib_3;  // Item reexports of items_3_1 and items_3_2
+mod items_4_1;
+mod items_4_2;
+mod items_4_3;
+mod items_4_4;
+mod lib_4;  // Item reexports of items_4_1 and items_4_2
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/tests.sw
new file mode 100644
index 00000000000..2457aeacce0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/src/tests.sw
@@ -0,0 +1,273 @@
+library;
+
+// Reexported items from items_1.sw. All reexports shadowed by private local definitions in lib_1.sw.
+use ::lib_1::*;
+ // Reexported items from items_2_1.sw and items_2_2.sw. All reexports from items_2_1.sw are
+ // shadowed by items imported and not reexported from items_2_2.sw
+use ::lib_2::*;
+// Reexported items from items_3_1.sw and items_3_2.sw. All reexports shadowed by private local
+// definitions in lib_3.sw.
+use ::lib_3::Items3_Struct;
+use ::lib_3::Items3_Enum;
+use ::lib_3::Items3_Variants;
+use ::lib_3::Items3_Variants::G;
+use ::lib_3::Items3_Variants::H;
+use ::lib_3::ITEMS_3_FUNCTION_RES;
+use ::lib_3::items_3_function;
+use ::lib_3::Items3Trait;
+
+// Reexported items from items_4_1.sw and items_4_2.sw. All reexports from items_4_1.sw are
+// shadowed by items imported and not reexported from items_4_2.sw
+use ::lib_4::Items4_Struct;
+use ::lib_4::Items4_Enum;
+use ::lib_4::Items4_Variants;
+
+// This ought to be possible, but Items4_Variants is interpreted as a module rather than as an enum.
+use ::lib_4::Items4_Variants::K;
+use ::lib_4::Items4_Variants::L;
+// Using the variant names directly works, but that's not how the test should work.
+// Uncomment the previous two imports and remove these next two when the problem has been resolved.
+//use ::lib_4::K;
+//use ::lib_4::L;
+
+use ::lib_4::ITEMS_4_FUNCTION_RES;
+use ::lib_4::items_4_function;
+use ::lib_4::Items4Trait;
+// Items4_Variants2 defined in items_4_4.sw, variants reexported by lib_4.sw
+use ::items_4_4::Items4_Variants2;
+use ::lib_4::M;
+use ::lib_4::N;
+
+
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    self.Z
+	}
+	else {
+	    0
+	}
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.b
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::C(val) => val,
+	Items2_Enum::D(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    0
+	}
+	else {
+	    self.Z
+	}
+    }
+}
+
+
+// lib_3 tests
+
+fn project_items_3_struct(input: Items3_Struct) -> u64 {
+    input.c
+}
+
+fn project_items_3_enum(input: Items3_Enum) -> u64 {
+    match input {
+	Items3_Enum::E(val) => val,
+	Items3_Enum::F(val) => val + 1000,
+    }
+}
+
+fn project_items_3_variants(input: Items3_Variants) -> u64 {
+    match input {
+	Items3_Variants::G(val) => val,
+	Items3_Variants::H(val) => val + 1000,
+    }
+}
+
+fn call_items_3_function() -> u64 {
+    items_3_function()
+}
+
+impl Items3Trait<TestStruct2> for TestStruct1 {
+    fn items_3_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    self.Z
+	}
+	else {
+	    0
+	}
+    }
+}
+
+// lib_4 tests
+
+fn project_items_4_struct(input: Items4_Struct) -> u64 {
+    input.d
+}
+
+fn project_items_4_enum(input: Items4_Enum) -> u64 {
+    match input {
+	Items4_Enum::I(val) => val,
+	Items4_Enum::J(val) => val + 1000,
+    }
+}
+
+fn project_items_4_variants(input: Items4_Variants) -> u64 {
+    match input {
+	K(val) => val,
+	L(val) => val + 1000,
+    }
+}
+
+fn call_items_4_function() -> u64 {
+    items_4_function()
+}
+
+impl Items4Trait<TestStruct2> for TestStruct1 {
+    fn items_4_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    0
+	}
+	else {
+	    self.Z
+	}
+    }
+}
+
+fn project_items_4_variants2(input: Items4_Variants2) -> u64 {
+    match input {
+	M(val) => val,
+	N(val) => val + 1000,
+    }
+}
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res == 64);
+
+
+    let items_2_struct = Items2_Struct { b: 879 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 879);
+
+    let items_2_enum = Items2_Enum::C(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res == 128);
+
+
+    let items_3_struct = Items3_Struct { c: 123 };
+    let items_3_struct_res = project_items_3_struct(items_3_struct);
+    assert(items_3_struct_res == 123);
+
+    let items_3_enum = Items3_Enum::E(432);
+    let items_3_enum_res = project_items_3_enum(items_3_enum);
+    assert(items_3_enum_res == 432);
+
+    let items_3_variants = G(432);
+    let items_3_variants_res = project_items_3_variants(items_3_variants);
+    assert(items_3_variants_res == 432);
+
+    let items_3_function_res = call_items_3_function();
+    assert(items_3_function_res == ITEMS_3_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+    assert(items_3_trait_teststruct_1_res == 64);
+
+    
+    let items_4_struct = Items4_Struct { d: 879 };
+    let items_4_struct_res = project_items_4_struct(items_4_struct);
+    assert(items_4_struct_res == 879);
+
+    let items_4_enum = Items4_Enum::I(446);
+    let items_4_enum_res = project_items_4_enum(items_4_enum);
+    assert(items_4_enum_res == 446);
+
+    let items_4_variants = K(446);
+    let items_4_variants_res = project_items_4_variants(items_4_variants);
+    assert(items_4_variants_res == 446);
+
+    let items_4_function_res = call_items_4_function();
+    assert(items_4_function_res == ITEMS_4_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 148 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_4_trait_teststruct_1_res = teststruct_1.items_4_trait_function(teststruct_2);
+    assert(items_4_trait_teststruct_1_res == 148);
+
+    let items_4_variants2 = M(446);
+    let items_4_variants2_res = project_items_4_variants2(items_4_variants2);
+    assert(items_4_variants2_res == 446);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/test.toml
new file mode 100755
index 00000000000..700594e5116
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/shadowing_in_reexporting_module/test.toml
@@ -0,0 +1,191 @@
+category = "fail"
+
+#check: $()error
+#check: $()use ::lib_3::Items3_Struct;
+#nextln: $()Symbol "Items3_Struct" is private.
+
+#check: $()error
+#check: $()use ::lib_3::Items3_Enum;
+#nextln: $()Symbol "Items3_Enum" is private.
+
+#check: $()error
+#check: $()use ::lib_3::Items3_Variants;
+#nextln: $()Symbol "Items3_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_3::Items3_Variants::G;
+#nextln: $()Symbol "Items3_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_3::Items3_Variants::H;
+#nextln: $()Symbol "Items3_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_3::ITEMS_3_FUNCTION_RES;
+#nextln: $()Symbol "ITEMS_3_FUNCTION_RES" is private.
+
+#check: $()error
+#check: $()use ::lib_3::items_3_function;
+#nextln: $()Symbol "items_3_function" is private.
+
+#check: $()error
+#check: $()use ::lib_3::Items3Trait;
+#nextln: $()Symbol "Items3Trait" is private.
+
+#check: $()error
+#check: $()use ::lib_4::Items4_Struct;
+#nextln: $()Symbol "Items4_Struct" is private.
+
+#check: $()error
+#check: $()use ::lib_4::Items4_Enum;
+#nextln: $()Symbol "Items4_Enum" is private.
+
+#check: $()error
+#check: $()use ::lib_4::Items4_Variants;
+#nextln: $()Symbol "Items4_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_4::Items4_Variants::K;
+#nextln: $()Symbol "Items4_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_4::Items4_Variants::L;
+#nextln: $()Symbol "Items4_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_4::ITEMS_4_FUNCTION_RES;
+#nextln: $()Symbol "ITEMS_4_FUNCTION_RES" is private.
+
+#check: $()error
+#check: $()use ::lib_4::items_4_function;
+#nextln: $()Symbol "items_4_function" is private.
+
+#check: $()error
+#check: $()use ::lib_4::Items4Trait;
+#nextln: $()Symbol "Items4Trait" is private.
+
+#check: $()error
+#check: $()use ::lib_4::M;
+#nextln: $()Symbol "M" is private.
+
+#check: $()error
+#check: $()use ::lib_4::N;
+#nextln: $()Symbol "N" is private.
+
+#check: $()error
+#check: $()input.a
+#nextln: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()input.a
+#nextln: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()Items1_Enum::A(val) => val,
+#nextln: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()Items1_Enum::B(val) => val + 1000,
+#nextln: $()No method named "add" found for type "bool".
+
+#check: $()error
+#check: $()items_1_function()
+#check: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()items_1_function()
+#check: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()fn items_1_trait_function(self, x: TestStruct2) -> u64 {
+#nextln: $()expected: bool
+#nextln: $()found:    u64
+
+#check: $()error
+#check: $()input.b
+#nextln: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()input.b
+#nextln: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()Items2_Enum::C(val) => val,
+#nextln: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()Items2_Enum::D(val) => val + 1000,
+#nextln: $()No method named "add" found for type "bool".
+
+#check: $()error
+#check: $()items_2_function()
+#check: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()items_2_function()
+#check: $()Mismatched types.
+#nextln: $()expected: u64
+#nextln: $()found:    bool.
+
+#check: $()error
+#check: $()fn items_2_trait_function(self, x: TestStruct2) -> u64 {
+#nextln: $()expected: bool
+#nextln: $()found:    u64
+
+#check: $()error
+#check: $()let items_1_struct = Items1_Struct { a: 123 };
+#nextln: $()Mismatched types.
+#nextln: $()expected: bool
+#nextln: $()found:    numeric.
+
+#check: $()error
+#check: $()let items_1_enum = Items1_Enum::A(432);
+#nextln: $()Mismatched types.
+#nextln: $()expected: bool
+#nextln: $()found:    numeric.
+
+#check: $()error
+#check: $()let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+#nextln: $()Cannot call associated function "items_1_trait_function" as a method. Use associated function syntax instead.
+
+#check: $()error
+#check: $()let items_2_struct = Items2_Struct { b: 879 };
+#nextln: $()Mismatched types.
+#nextln: $()expected: bool
+#nextln: $()found:    numeric.
+
+#check: $()error
+#check: $()let items_2_enum = Items2_Enum::C(246);
+#nextln: $()Mismatched types.
+#nextln: $()expected: bool
+#nextln: $()found:    numeric.
+
+#check: $()error
+#check: $()let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+#nextln: $()Cannot call associated function "items_2_trait_function" as a method. Use associated function syntax instead.
+
+#check: $()error
+#check: $()This path must return a value of type "u64" from function "items_1_trait_function", but it does not.
+
+#check: $()error
+#check: $()This path must return a value of type "u64" from function "items_2_trait_function", but it does not.
+
+#check: $()Aborting due to 42 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/Forc.lock
new file mode 100755
index 00000000000..12796c9cfa0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-01E3D9B036D3B866"
+
+[[package]]
+name = "simple_glob_import"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-01E3D9B036D3B866"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/Forc.toml
new file mode 100755
index 00000000000..e9e0963dbff
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "simple_glob_import"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/json_abi_oracle_new_encoding.json
old mode 100644
new mode 100755
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/json_abi_oracle_new_encoding.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/json_abi_oracle_new_encoding.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/items_2.sw
new file mode 100755
index 00000000000..654a63ac267
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub n: u64,
+}
+
+pub enum Items2_Enum {
+    N: u64,
+    M: u64,
+}
+
+pub enum Items2_Variants {
+    O: u64,
+    P: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/lib_1.sw
new file mode 100644
index 00000000000..27a37d85825
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+use ::items_1::Items1_Struct;
+
+use ::items_1::Items1_Enum;
+
+use ::items_1::Items1_Variants::X;
+use ::items_1::Items1_Variants::Y;
+
+use ::items_1::ITEMS_1_FUNCTION_RES;
+
+use ::items_1::items_1_function;
+
+use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/lib_2.sw
new file mode 100644
index 00000000000..85f030aa50f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/lib_2.sw
@@ -0,0 +1,5 @@
+library;
+
+use ::items_2::*;
+
+use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/main.sw
new file mode 100755
index 00000000000..57262307323
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2;
+mod lib_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/tests.sw
new file mode 100644
index 00000000000..acc811144b9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/src/tests.sw
@@ -0,0 +1,126 @@
+library;
+
+use ::lib_1::*; // Items from items_1.sw not reexported. All imports are item imports
+use ::lib_2::*; // Items from items_2.sw not reexported. All imports are glob imports
+
+use ::items_1::Items1_Variants;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.n
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::N(val) => val,
+	Items2_Enum::M(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	O(val) => val,
+	P(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Items2_Struct { n: 789 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 789);
+
+    let items_2_enum = Items2_Enum::N(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = O(468);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/test.toml
new file mode 100755
index 00000000000..a17f001163a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_glob_import/test.toml
@@ -0,0 +1,129 @@
+category = "fail"
+
+#check: $()error
+#check: $()Could not find symbol "Items1_Struct" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items1_Struct"
+
+#check: $()error
+#check: $()Could not find symbol "Items1_Enum" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items1_Enum".
+
+#check: $()error
+#check: $()Could not find symbol "X" in this scope.
+
+#check: $()error
+#check: $()Could not find symbol "Y" in this scope.
+
+#check: $()error
+#check: $()Could not find symbol "items_1_function" in this scope.
+
+#check: $()error
+#check: $()Could not find symbol "Items1Trait" in this scope.
+
+#check: $()error
+#check: $()Trait "Items1Trait" cannot be found in the current scope.
+
+#check: $()error
+#check: $()Could not find symbol "Items2_Struct" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items2_Struct".
+
+#check: $()error
+#check: $()Could not find symbol "Items2_Enum" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items2_Enum".
+
+#check: $()error
+#check: $()Could not find symbol "Items2_Variants" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items2_Variants".
+
+#check: $()error
+#check: $()Could not find symbol "items_2_function" in this scope.
+
+#check: $()error
+#check: $()Could not find symbol "Items2Trait" in this scope.
+
+#check: $()error
+#check: $()Trait "Items2Trait" cannot be found in the current scope.
+
+#check: $()error
+#check: $()Could not find symbol "Items1_Struct" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items1_Struct".
+
+#check: $()error
+#check: $()Could not find symbol "project_items_1_struct" in this scope.
+
+#check: $()error
+#check: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()Could not find symbol "Items1_Enum" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items1_Enum".
+
+#check: $()error
+#check: $()Could not find symbol "project_items_1_enum" in this scope.
+
+#check: $()error
+#check: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()Could not find symbol "X" in this scope.
+
+#check: $()error
+#check: $()Variable "ITEMS_1_FUNCTION_RES" does not exist in this scope.
+
+#check: $()error
+#check: $()No method named "items_1_trait_function" found for type "TestStruct1".
+
+#check: $()error
+#check: $()Could not find symbol "Items2_Struct" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items2_Struct".
+
+#check: $()error
+#check: $()Could not find symbol "project_items_2_struct" in this scope.
+
+#check: $()error
+#check: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()Could not find symbol "Items2_Enum" in this scope.
+
+#check: $()error
+#check: $()Unknown type name "Items2_Enum".
+
+#check: $()error
+#check: $()Could not find symbol "project_items_2_enum" in this scope.
+
+#check: $()error
+#check: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()Could not find symbol "O" in this scope.
+
+#check: $()error
+#check: $()Could not find symbol "project_items_2_variants" in this scope.
+
+#check: $()error
+#check: $()No method named "eq" found for type "{unknown}".
+
+#check: $()error
+#check: $()Variable "ITEMS_2_FUNCTION_RES" does not exist in this scope.
+
+#check: $()error
+#check: $()No method named "items_2_trait_function" found for type "TestStruct1".
+
+#check: $()Aborting due to 42 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/Forc.lock
new file mode 100755
index 00000000000..3153bd921ae
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-628D42C449EC89D5"
+
+[[package]]
+name = "simple_item_import"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-628D42C449EC89D5"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/Forc.toml
new file mode 100755
index 00000000000..37dd2996343
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "simple_item_import"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/json_abi_oracle_new_encoding.json
old mode 100644
new mode 100755
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/json_abi_oracle_new_encoding.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/json_abi_oracle_new_encoding.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_2.sw
new file mode 100755
index 00000000000..654a63ac267
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub n: u64,
+}
+
+pub enum Items2_Enum {
+    N: u64,
+    M: u64,
+}
+
+pub enum Items2_Variants {
+    O: u64,
+    P: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_3.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_3.sw
new file mode 100644
index 00000000000..36e1338e4cc
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/items_3.sw
@@ -0,0 +1,6 @@
+library;
+
+pub enum Items3_Variants {
+    S: u64,
+    T: u64,
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_1.sw
new file mode 100644
index 00000000000..27a37d85825
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+use ::items_1::Items1_Struct;
+
+use ::items_1::Items1_Enum;
+
+use ::items_1::Items1_Variants::X;
+use ::items_1::Items1_Variants::Y;
+
+use ::items_1::ITEMS_1_FUNCTION_RES;
+
+use ::items_1::items_1_function;
+
+use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_2.sw
new file mode 100644
index 00000000000..85f030aa50f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_2.sw
@@ -0,0 +1,5 @@
+library;
+
+use ::items_2::*;
+
+use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_3.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_3.sw
new file mode 100644
index 00000000000..f2bb86f118f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/lib_3.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use ::items_3::Items3_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/main.sw
new file mode 100755
index 00000000000..57262307323
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2;
+mod lib_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/tests.sw
new file mode 100644
index 00000000000..dc37866d715
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/src/tests.sw
@@ -0,0 +1,158 @@
+library;
+
+ // Reexported items from items_1.sw. All reexports are item imports
+use ::lib_1::Items1_Struct;
+use ::lib_1::Items1_Enum;
+use ::lib_1::X;
+use ::lib_1::Y;
+use ::lib_1::ITEMS_1_FUNCTION_RES;
+use ::lib_1::items_1_function;
+use ::lib_1::Items1Trait;
+
+// Reexported items from items_2.sw. All reexports are glob imports
+use ::lib_2::Items2_Struct;
+use ::lib_2::Items2_Enum;
+use ::lib_2::Items2_Variants;
+use ::lib_2::O;
+use ::lib_2::P;
+use ::lib_2::ITEMS_2_FUNCTION_RES;
+use ::lib_2::items_2_function;
+use ::lib_2::Items2Trait;
+
+// Edge case: pub use Enum_name::* should not cause Enum_name::X to be a legal path
+use ::lib_3::Items3_Variants::S;
+
+// Needed to match on Items1_Variants::{X, Y}
+use ::items_1::Items1_Variants;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.n
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::N(val) => val,
+	Items2_Enum::M(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	O(val) => val,
+	P(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+// lib_3 tests
+
+fn project_items_3_variants(input: Items3_Variants) -> u64 {
+    match input {
+	Items3_Variants::S(val) => val,
+	Items3_Variants::T(val) => val + 1000,
+    }
+}
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Items2_Struct { n: 789 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 789);
+
+    let items_2_enum = Items2_Enum::N(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = O(468);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    let items_3_variants = Items3_Variants::S(513);
+    let items_3_variants_res = project_items_3_variants(items_3_variants);
+    assert(items_3_variants_res == 513);
+    
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/test.toml
new file mode 100755
index 00000000000..3e1058ab30e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_item_import/test.toml
@@ -0,0 +1,91 @@
+category = "fail"
+
+#check: $()error
+#check: $()use ::lib_1::Items1_Struct;
+#nextln: $()Symbol "Items1_Struct" is private.
+
+#check: $()error
+#check: $()use ::lib_1::Items1_Enum;
+#nextln: $()Symbol "Items1_Enum" is private.
+
+#check: $()error
+#check: $()use ::lib_1::X;
+#nextln: $()Symbol "X" is private.
+
+#check: $()error
+#check: $()use ::lib_1::Y;
+#nextln: $()Symbol "Y" is private.
+
+#check: $()error
+#check: $()use ::lib_1::ITEMS_1_FUNCTION_RES;
+#nextln: $()Symbol "ITEMS_1_FUNCTION_RES" is private.
+
+#check: $()error
+#check: $()use ::lib_1::items_1_function;
+#nextln: $()Symbol "items_1_function" is private.
+
+#check: $()error
+#check: $()use ::lib_1::Items1Trait;
+#nextln: $()Symbol "Items1Trait" is private.
+
+#check: $()error
+#check: $()use ::lib_2::Items2_Struct;
+#nextln: $()Symbol "Items2_Struct" is private.
+
+#check: $()error
+#check: $()use ::lib_2::Items2_Enum;
+#nextln: $()Symbol "Items2_Enum" is private.
+
+#check: $()error
+#check: $()use ::lib_2::Items2_Variants;
+#nextln: $()Symbol "Items2_Variants" is private.
+
+#check: $()error
+#check: $()use ::lib_2::O;
+#nextln: $()Symbol "O" is private.
+
+#check: $()error
+#check: $()use ::lib_2::P;
+#nextln: $()Symbol "P" is private.
+
+#check: $()error
+#check: $()use ::lib_2::ITEMS_2_FUNCTION_RES;
+#nextln: $()Symbol "ITEMS_2_FUNCTION_RES" is private.
+
+#check: $()error
+#check: $()use ::lib_2::items_2_function;
+#nextln: $()Symbol "items_2_function" is private.
+
+#check: $()error
+#check: $()use ::lib_2::Items2Trait;
+#nextln: $()Symbol "Items2Trait" is private.
+
+#check: $()error
+#check: $()use ::lib_3::Items3_Variants::S;
+#nextln: $()Module "lib_3::Items3_Variants" could not be found.
+
+#check: $()error
+#check: $()fn project_items_3_variants(input: Items3_Variants) -> u64 {
+#nextln: $()Could not find symbol "Items3_Variants" in this scope.
+
+#check: $()error
+#check: $()fn project_items_3_variants(input: Items3_Variants) -> u64 {
+#nextln: $()Unknown type name "Items3_Variants".
+
+#check: $()error
+#check: $()let items_3_variants = Items3_Variants::S(513);
+#nextln: $()Could not find symbol "Items3_Variants" in this scope.
+
+#check: $()error
+#check: $()let items_3_variants = Items3_Variants::S(513);
+#nextln: $()Unknown type name "Items3_Variants".
+
+#check: $()error
+#check: $()let items_3_variants_res = project_items_3_variants(items_3_variants);
+#nextln: $()Could not find symbol "project_items_3_variants" in this scope.
+
+#check: $()error
+#check: $()assert(items_3_variants_res == 513);
+#nextln: $()No method named "eq" found for type "{unknown}".
+
+#check: $()Aborting due to 22 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/Forc.lock
new file mode 100755
index 00000000000..a7cf53ac834
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-F3FE5D74B284BFAB"
+
+[[package]]
+name = "simple_path_access"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-F3FE5D74B284BFAB"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/Forc.toml
new file mode 100755
index 00000000000..dbc40b43ba1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "simple_path_access"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/json_abi_oracle_new_encoding.json
old mode 100644
new mode 100755
similarity index 88%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/json_abi_oracle_new_encoding.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/json_abi_oracle_new_encoding.json
index e60dda965d4..068da3305ab
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/json_abi_oracle_new_encoding.json
@@ -17,8 +17,8 @@
   "messagesTypes": [],
   "types": [
     {
-      "components": [],
-      "type": "()",
+      "components": null,
+      "type": "u64",
       "typeId": 0,
       "typeParameters": null
     }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/items_2.sw
new file mode 100755
index 00000000000..250723123de
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub n: u64,
+}
+
+pub enum Items2_Enum {
+    N: u64,
+    M: u64,
+}
+
+pub enum Items2_Variants {
+    O: u64,
+    P: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/lib_1.sw
new file mode 100644
index 00000000000..27a37d85825
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+use ::items_1::Items1_Struct;
+
+use ::items_1::Items1_Enum;
+
+use ::items_1::Items1_Variants::X;
+use ::items_1::Items1_Variants::Y;
+
+use ::items_1::ITEMS_1_FUNCTION_RES;
+
+use ::items_1::items_1_function;
+
+use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/lib_2.sw
new file mode 100644
index 00000000000..85f030aa50f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/lib_2.sw
@@ -0,0 +1,5 @@
+library;
+
+use ::items_2::*;
+
+use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/main.sw
new file mode 100755
index 00000000000..57262307323
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2;
+mod lib_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/tests.sw
new file mode 100644
index 00000000000..3dcd5515781
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/src/tests.sw
@@ -0,0 +1,96 @@
+library;
+
+// Disabled
+// This test is supposed to test that `use` without `pub` makes the item private,
+// but the path resolution is broken, so the test doesn't test what it's supposed to test.
+
+use ::items_1::Items1_Variants;
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+impl ::lib_1::Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+impl ::lib_2::Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+
+pub fn run_all_tests() -> u64 {
+    // lib_1 tests
+    let items_1_struct = ::lib_1::Items1_Struct { a: 123 };
+    assert(items_1_struct.a == 123);
+
+    let items_1_enum = ::lib_1::Items1_Enum::A(432);
+    let items_1_enum_res = match items_1_enum {
+	::items_1::Items1_Enum::A(val) => val,
+	::items_1::Items1_Enum::B(val) => val + 1000,
+    };
+    assert(items_1_enum_res == 432);
+
+    // TODO: Should this be allowed? ::lib_1::X refers to ::items_1::Items1_Variants::X.
+    let items_1_variants = ::lib_1::X(680);
+    let items_1_variants_res = match items_1_variants {
+	::items_1::Items1_Variants::X(val) => val,
+	::items_1::Items1_Variants::Y(val) => val + 1000,
+    };
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = ::lib_1::items_1_function();
+    let items_1_function_oracle = ::lib_1::ITEMS_1_FUNCTION_RES;
+    assert(items_1_function_res == items_1_function_oracle);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+    // lib_2 tests
+
+    let items_2_struct = ::lib_2::Items2_Struct { n: 789 };
+    assert(items_2_struct.n == 789);
+
+    let items_2_enum = ::lib_2::Items2_Enum::N(246);
+    let items_2_enum_res = match items_2_enum {
+	::items_2::Items2_Enum::N(val) => val,
+	::items_2::Items2_Enum::M(val) => val + 1000,
+    };
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = ::lib_2::O(468);
+    let items_2_variants_res = match items_2_variants {
+	::items_2::Items2_Variants::O(val) => val,
+	::items_2::Items2_Variants::P(val) => val + 1000,
+    };
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = ::lib_2::call_items_2_function();
+    let items_2_function_oracle = ::lib_2::ITEMS_2_FUNCTION_RES;
+    assert(items_2_function_res == items_2_function_oracle);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/test.toml
new file mode 100755
index 00000000000..5256044dda0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/reexport/simple_path_access/test.toml
@@ -0,0 +1,4 @@
+category = "disabled"
+expected_warnings = 0
+
+#not: $()error
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/src/main.sw
index 2ac2c7d689c..fdb23ee4366 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/src/main.sw
@@ -15,6 +15,10 @@ impl S {
     const X = 0;
 }
 
+struct S2 {
+    s: S,
+}
+
 fn function(f_x: u8) {
     let _ = &mut f_x;
 }
@@ -73,5 +77,18 @@ fn main() {
     }
 
     function(0);
+
+    // aggregates checking
+
+    let _ = &mut s.x;
+
+    let s2 = S2 { s: S { x: 0 } };
+
+    let _ = &mut s2.s.x;
+
+    let t : (u32, u32) = (0, 0);
+    let _ : &mut u32 = &mut t.0;
+
+    let _ = &mut { t }; // No error here.
 }
 
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/test.toml
index e7881b96223..f8038d39421 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/test.toml
@@ -93,3 +93,24 @@ category = "fail"
 #check: $()let _ = &mut n;
 #nextln: $()"n" is an immutable variable. `&mut` cannot reference immutable variables.
 #check: $()- referencing a mutable copy of "n", by returning it from a block: `&mut { n }`.
+
+#check: $()References to mutable values cannot reference immutable variables
+#check: $()let s = S { x: 0 };
+#nextln: $()Variable "s" is declared here as immutable.
+#check: $()let _ = &mut s.x;
+#nextln: $()"s" is an immutable variable. `&mut` cannot reference immutable variables.
+#check: $()- referencing a mutable copy of "s", by returning it from a block: `&mut { s }`.
+
+#check: $()References to mutable values cannot reference immutable variables
+#check: $()let s2 = S2 { s: S { x: 0 } };
+#nextln: $()Variable "s2" is declared here as immutable.
+#check: $()let _ = &mut s2.s.x;
+#nextln: $()"s2" is an immutable variable. `&mut` cannot reference immutable variables.
+#check: $()- referencing a mutable copy of "s2", by returning it from a block: `&mut { s2 }`.
+
+#check: $()References to mutable values cannot reference immutable variables
+#check: $()let t : (u32, u32) = (0, 0);
+#nextln: $()Variable "t" is declared here as immutable.
+#check: $()let _ : &mut u32 = &mut t.0;
+#nextln: $()"t" is an immutable variable. `&mut` cannot reference immutable variables.
+#check: $()- referencing a mutable copy of "t", by returning it from a block: `&mut { t }`.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/.gitignore b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/Forc.lock
similarity index 55%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/Forc.lock
index 9a2789f0bcb..d8670265e2e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/Forc.lock
@@ -1,8 +1,8 @@
 [[package]]
 name = "core"
-source = "path+from-root-D8328229BADFFAD9"
+source = "path+from-root-082ED3C1A64D1BB4"
 
 [[package]]
-name = "str_slice"
+name = "lexer_errors"
 source = "member"
 dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/Forc.toml
new file mode 100644
index 00000000000..1b354765afa
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "lexer_errors"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/src/main.sw
new file mode 100644
index 00000000000..2afd00663ab
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/src/main.sw
@@ -0,0 +1,15 @@
+library;
+
+pub struct R {
+    a: u32,
+}
+
+impl R {
+    pub fn from_str(new: i32) {
+p() {
+  :Script => {
+   c = ZERO_B256;
+    ), }
+}
+
+const OFFSET = 0;
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/test.toml
new file mode 100644
index 00000000000..1564ded8e80
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/lexer_errors/test.toml
@@ -0,0 +1,8 @@
+category = "fail"
+
+# check: $()error
+# check: $()mismatched delimiters
+
+# check: $()error
+# check: $()impl R {
+# nextln: $()unclosed delimiter
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/Forc.lock
new file mode 100644
index 00000000000..93daf379ca5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "method_missing_constraint"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/Forc.toml
new file mode 100644
index 00000000000..4bfc75e72b9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "method_missing_constraint"
+entry = "main.sw"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/json_abi_oracle.json
new file mode 100644
index 00000000000..0637a088a01
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/json_abi_oracle.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/src/main.sw
new file mode 100644
index 00000000000..e1a48078c2f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/src/main.sw
@@ -0,0 +1,21 @@
+script;
+
+trait T1 {}
+trait T2 {}
+struct S<T> where T: T1 {
+ x: T,
+}
+impl<T> S<T> where T: T1{
+ fn only_t1(self) {
+ Self::also_t2(self);
+ }
+ fn also_t2(self) where T: T2{
+ }
+}
+impl T1 for u8 {}
+impl T1 for u64 {}
+impl T2 for u64 {}
+fn main() {
+ let a = S::<u8>{x: 42};
+ a.only_t1(); //prints Hello but u8 doesn't implement T2
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/test.toml
new file mode 100644
index 00000000000..cc9d2a0e61f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/method_missing_constraint/test.toml
@@ -0,0 +1,4 @@
+category = "fail"
+
+# check: $()Self::also_t2(self);
+# nextln: $()Trait "T2" is not implemented for type "T".
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/Forc.lock
new file mode 100644
index 00000000000..a0991ddd91b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-F62FA9D54ABC8F01"
+
+[[package]]
+name = "mismatch_closing_delimiters"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/Forc.toml
new file mode 100644
index 00000000000..084875b06eb
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "mismatch_closing_delimiters"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/src/main.sw
new file mode 100644
index 00000000000..22272bdf326
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/src/main.sw
@@ -0,0 +1,14 @@
+script;
+
+struct Struct{x:u}
+impl Struct{
+    fn w()->f{{(()}}
+    trait Supertrait{}
+    impl Supertrait for Struct{)
+}
+
+fn s<A>(b:B) where A:t{}fn n(){}
+
+fn main() -> u64 {
+    0
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/test.toml
new file mode 100644
index 00000000000..e3280310725
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/mismatch_closing_delimiters/test.toml
@@ -0,0 +1,4 @@
+category = "fail"
+
+# check: $()fn w()->f{{(()}}
+# nextln: $()mismatched delimiters
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/Forc.lock
new file mode 100644
index 00000000000..d0ea2d085b5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-6B977435DD9C5058"
+
+[[package]]
+name = "missing_hash_trait"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-6B977435DD9C5058"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/Forc.toml
new file mode 100644
index 00000000000..69067b7baaa
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "missing_hash_trait"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../sway-lib-std" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/src/main.sw
new file mode 100644
index 00000000000..478ee462af3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/src/main.sw
@@ -0,0 +1,22 @@
+contract;
+
+struct MyStruct {
+    val: u64
+}
+
+abi MyContract {
+    #[storage(read, write)]
+    fn test_function();
+}
+
+storage {
+    my_map: StorageMap<MyStruct, u64> = StorageMap::<MyStruct, u64> {},
+}
+
+impl MyContract for Contract {
+    #[storage(read, write)]
+    fn test_function() {
+        let my_struct = MyStruct { val: 1 };
+        storage.my_map.insert(my_struct, 2)
+    }
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/test.toml
new file mode 100644
index 00000000000..50547fb25c4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/missing_hash_trait/test.toml
@@ -0,0 +1,5 @@
+category = "fail"
+
+# check: $()storage.my_map.insert(my_struct, 2)
+# nextln: $()Trait "Hash" is not implemented for type "MyStruct".
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/src/main.sw
index 6927766f189..08605fa28fa 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/src/main.sw
@@ -1,10 +1,43 @@
 script;
 
+struct S {}
+
+impl S {
+    fn one_generic<T>(self) { }
+    fn two_generics<A, B>(self) { }
+}
+
+struct W<A> { }
+
 fn main() {
     let g: bool = three_generics(true, "foo", 10);
+
+    // Should fail because compiler cannot infer generic argument T
+    one_generic();
+
+    // Should fail because compiler cannot infer generic arguments A, B
+    two_generics();
+
+    // Two generics arguments expected
+    two_generics::<u64>();
+
+    // Should fail because compiler cannot infer generic argument T
+    S{}.one_generic();
+
+    // Should fail because compiler cannot infer generic arguments A, B
+    S{}.two_generics();
+
+    // Two generics arguments expected
+    S{}.two_generics::<u64>();
+
+    // Missing generic argument of W
+    one_generic::<W>();
 }
 
 fn three_generics(a: A, b: B, c: C) -> A {
     let new_a: A = a;
     new_a
 }
+
+fn one_generic<T>() { }
+fn two_generics<A, B>() { }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/test.toml
index af45dbb8e7e..471410b9291 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/missing_type_parameters/test.toml
@@ -6,3 +6,30 @@ category = "fail"
 # check: $()Unknown type name "B"
 # check: $()Could not find symbol "C" in this scope.
 # check: $()Unknown type name "C"
+
+# check: $()two_generics::<u64>();
+# nextln: $()Expected 2 type arguments for "two_generics", but instead found 1.
+
+# check: $()S{}.two_generics::<u64>();
+# nextln: $()Expected 2 type arguments for "two_generics", but instead found 1.
+
+# check: $()one_generic()
+# nextln: $()Cannot infer type for type parameter "T". Insufficient type information provided. Try annotating its type.
+
+# check: $()two_generics();
+# nextln: $()Cannot infer type for type parameter "A". Insufficient type information provided. Try annotating its type.
+
+# check: $()two_generics();
+# nextln: $()Cannot infer type for type parameter "B". Insufficient type information provided. Try annotating its type.
+
+# check: $()S{}.one_generic()
+# nextln: $()Cannot infer type for type parameter "T". Insufficient type information provided. Try annotating its type.
+
+# check: $()S{}.two_generics();
+# nextln: $()Cannot infer type for type parameter "A". Insufficient type information provided. Try annotating its type.
+
+# check: $()S{}.two_generics();
+# nextln: $()Cannot infer type for type parameter "B". Insufficient type information provided. Try annotating its type.
+
+# check: $()one_generic::<W>();
+# nextln: $()Cannot infer type for type parameter "A". Insufficient type information provided. Try annotating its type.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/multiple_enums_with_the_same_name/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/multiple_enums_with_the_same_name/test.toml
index 7e241fe3e04..05cc5d38e5b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/multiple_enums_with_the_same_name/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/multiple_enums_with_the_same_name/test.toml
@@ -1,4 +1,4 @@
-category = "disabled"
+category = "fail"
 
 # check: $()x = y;
 # nextln: $()Mismatched types.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/multiple_structs_with_the_same_name/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/multiple_structs_with_the_same_name/test.toml
index 7e241fe3e04..05cc5d38e5b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/multiple_structs_with_the_same_name/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/multiple_structs_with_the_same_name/test.toml
@@ -1,4 +1,4 @@
-category = "disabled"
+category = "fail"
 
 # check: $()x = y;
 # nextln: $()Mismatched types.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.lock
index 8734cdecdfe..a0b7e6c299c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
-name = 'nested_impure'
-source = 'member'
+name = "core"
+source = "path+from-root-817B68A1DC27AFAA"
+
+[[package]]
+name = "nested_impure"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.toml
index d2c96a4c91b..5455877c6f9 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/Forc.toml
@@ -4,3 +4,6 @@ license = "Apache-2.0"
 name = "nested_impure"
 entry = "main.sw"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/src/main.sw
index 8ff02c223a7..65ad037f20d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/src/main.sw
@@ -1,22 +1,29 @@
 contract;
 
-fn main() {
-    foo();
+abi Abi {
+    fn test();
+}
+
+impl Abi for Contract {
+    fn test() {
+        foo();
+    }
 }
 
 fn foo() {
     bar();
-    baz();
+    let _ = baz();
 }
 
 // Although annotated, with no args is pure.
 #[storage()]
 fn bar() {
-    let z = baz();
+    let _ = baz();
 }
 
 // Explicitly impure.
 #[storage(read)]
 fn baz() -> u64 {
-  5
+    let _ = __state_load_word(b256::zero());
+    5
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/test.toml
index 7ce22172e4c..4f41f7c91e8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/nested_impure/test.toml
@@ -1,7 +1,27 @@
 category = "fail"
 
-# check: $()This returns a value of type u64, which is not assigned to anything and is ignored.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn bar()
+#nextln: $()Function "bar" is pure and cannot access storage.
+#check: $()let _ = baz();
+#nextln: $()Function "baz" reads from the storage.
+#check: $()Consider declaring the function "bar" as `#[storage(read)]`
 
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn foo()
+#nextln: $()Function "foo" is pure and cannot access storage.
+#check: $()bar();
+#nextln: $()Function "bar" reads from the storage.
+#check: $()let _ = baz();
+#nextln: $()Function "baz" reads from the storage.
+#check: $()Consider declaring the function "foo" as `#[storage(read)]`
 
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test()
+#nextln: $()Function "test" is pure and cannot access storage.
+#check: $()foo();
+#nextln: $()Function "foo" reads from the storage.
+#check: $()Consider declaring the function "test" as `#[storage(read)]`
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/Forc.lock
new file mode 100644
index 00000000000..0284e5bd9e5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-6C2FF70C66B98326"
+
+[[package]]
+name = "parser_associated_type_error"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-6C2FF70C66B98326"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/Forc.toml
new file mode 100644
index 00000000000..06817f2a91c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "parser_associated_type_error"
+
+[dependencies]
+std = { path = "../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/src/main.sw
new file mode 100644
index 00000000000..8f11dc585b4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/src/main.sw
@@ -0,0 +1,3 @@
+script;
+
+trait T{type E const C:Self::E::E}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/test.toml
new file mode 100644
index 00000000000..df5b315a430
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/parser_associated_type_error/test.toml
@@ -0,0 +1,6 @@
+category = "fail"
+
+# check: $()trait T{type E const C:Self::E::E}
+# nextln: $()Expected `;`.
+
+# check: $()Trait type declaration has no type
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/src/main.sw
index c4afb3c6574..1475bcf18f3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/src/main.sw
@@ -57,7 +57,7 @@ fn main() -> bool {
   };
 
   asm(r1: 0, r2: 0, r3: 0) {
-    ldc r1 r2 r3;
+    ldc r1 r2 r3 i0;
   }
 
   asm(r1: 0, r2: 0, r3: 0, r4: 0) {
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/test.toml
index b384ae9f5a9..05d73f3c66d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/predicate_invalid_opcodes/test.toml
@@ -35,7 +35,7 @@ category = "fail"
 
 # not: $()The GM (get-metadata) opcode, when called from an external context, will cause the VM to panic.
 
-# check: ldc r1 r2 r3;
+# check: ldc r1 r2 r3 i0;
 # nextln: $()The LDC opcode cannot be used in a predicate.
 
 # check: log r1 r2 r3 r4;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/src/main.sw
deleted file mode 100644
index 404c78ef543..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/src/main.sw
+++ /dev/null
@@ -1,14 +0,0 @@
-contract;
-
-// this should fail because a pure function cannot call an impure function
-
-fn main() {
-}
-
-
-fn pure_function() {
-  impure_function();
-}
-
-#[storage(write)]
-fn impure_function() {}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/test.toml
deleted file mode 100644
index 41a279dacfc..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/test.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-category = "fail"
-
-# check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(write)]" to the function declaration.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/Forc.lock
new file mode 100644
index 00000000000..087c33928e3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-EF0A42ACCA18193C"
+
+[[package]]
+name = "purity_of_asm_instructions_and_intrinsics"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/Forc.toml
new file mode 100644
index 00000000000..094bbe327e1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "purity_of_asm_instructions_and_intrinsics"
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/src/main.sw
new file mode 100644
index 00000000000..de537f296c0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/src/main.sw
@@ -0,0 +1,74 @@
+contract;
+
+abi Abi {
+    fn test();
+}
+
+struct S { }
+
+impl S {
+    fn read_intrinsics(self) -> Self {
+        let ptr = asm (p: 0) { p: raw_ptr };
+        let _ = __state_load_word(b256::zero());
+        let _ = __state_load_quad(b256::zero(), ptr, 1);
+
+        self
+    }
+
+    #[storage(read)]
+    fn write_intrinsics(self) -> Self {
+        let ptr = asm (p: 0) { p: raw_ptr };
+        let _ = __state_store_word(b256::zero(), 0);
+        let _ = __state_store_quad(b256::zero(), ptr, 1);
+
+        self
+    }
+
+    #[storage(read)]
+    fn clear_intrinsic(self) -> Self {
+        let _ = __state_clear(b256::zero(), 1);
+
+        self
+    }
+}
+
+impl Abi for Contract {
+    fn test() {
+        read_asm_instructions();
+        write_asm_instructions();
+        clear_asm_instruction();
+
+        let s = S {};
+        let _ = s.read_intrinsics();
+        let _ = s.write_intrinsics();
+        let _ = s.clear_intrinsic();
+    }
+}
+
+fn read_asm_instructions() {
+    asm(r1, r2, r3: 0) {
+        srw r1 r2 r3;
+    }
+
+    asm(r1: 0, r2, r3: 0, r4: 0) {
+        srwq r1 r2 r3 r4;
+    }
+}
+
+#[storage(read)]
+fn write_asm_instructions() {
+    asm(r1: 0, r2, r3: 0) {
+        sww r1 r2 r3;
+    }
+
+    asm(r1: 0, r2, r3: 0, r4: 0) {
+        swwq r1 r2 r3 r4;
+    }
+}
+
+#[storage(read)]
+fn clear_asm_instruction() {
+    asm(r1: 0, r2, r3: 0) {
+        scwq r1 r2 r3;
+    }
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/test.toml
new file mode 100644
index 00000000000..fa92c337a22
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/purity_of_asm_instructions_and_intrinsics/test.toml
@@ -0,0 +1,76 @@
+category = "fail"
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn read_asm_instructions()
+#nextln: $()Function "read_asm_instructions" is pure and cannot access storage.
+#check: $()srw r1 r2 r3;
+#nextln: $()Reading a word from the storage happens here.
+#check: $()srwq r1 r2 r3 r4;
+#nextln: $()Reading storage slots happens here.
+#check: $()Consider declaring the function "read_asm_instructions" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Storage read-only function cannot write to storage
+#check: $()fn write_asm_instructions()
+#nextln: $()Function "write_asm_instructions" is declared as `#[storage(read)]` and cannot write to storage.
+#check: $()sww r1 r2 r3;
+#nextln: $()Writing a word to the storage happens here.
+#check: $()swwq r1 r2 r3 r4;
+#nextln: $()Writing to storage slots happens here.
+#check: $()Consider declaring the function "write_asm_instructions" as `#[storage(read, write)]`
+
+#check: $()error
+#sameln: $()Storage read-only function cannot write to storage
+#check: $()fn clear_asm_instruction()
+#nextln: $()Function "clear_asm_instruction" is declared as `#[storage(read)]` and cannot write to storage.
+#check: $()scwq r1 r2 r3;
+#nextln: $()Clearing the storage happens here.
+#check: $()Consider declaring the function "clear_asm_instruction" as `#[storage(read, write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn read_intrinsics(self) -> Self
+#nextln: $()Function "read_intrinsics" is pure and cannot access storage.
+#check: $()let _ = __state_load_word(b256::zero());
+#nextln: $()Reading a word from the storage happens here.
+#check: $()let _ = __state_load_quad(b256::zero(), ptr, 1);
+#nextln: $()Reading storage slots happens here.
+#check: $()Consider declaring the function "read_intrinsics" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Storage read-only function cannot write to storage
+#check: $()fn write_intrinsics(self) -> Self
+#nextln: $()Function "write_intrinsics" is declared as `#[storage(read)]` and cannot write to storage.
+#check: $()let _ = __state_store_word(b256::zero(), 0);
+#nextln: $()Writing a word to the storage happens here.
+#check: $()let _ = __state_store_quad(b256::zero(), ptr, 1);
+#nextln: $()Writing to storage slots happens here.
+#check: $()Consider declaring the function "write_intrinsics" as `#[storage(read, write)]`
+
+#check: $()error
+#sameln: $()Storage read-only function cannot write to storage
+#check: $()fn clear_intrinsic(self) -> Self
+#nextln: $()Function "clear_intrinsic" is declared as `#[storage(read)]` and cannot write to storage.
+#check: $()let _ = __state_clear(b256::zero(), 1);
+#nextln: $()Clearing the storage happens here.
+#check: $()Consider declaring the function "clear_intrinsic" as `#[storage(read, write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test()
+#nextln: $()Function "test" is pure and cannot access storage.
+#check: $()read_asm_instructions();
+#nextln: $()Function "read_asm_instructions" reads from the storage.
+#check: $()write_asm_instructions();
+#nextln: $()Function "write_asm_instructions" writes to the storage.
+#check: $()clear_asm_instruction();
+#nextln: $()Function "clear_asm_instruction" writes to the storage.
+#check: $()let _ = s.read_intrinsics();
+#nextln: $()Function "read_intrinsics" reads from the storage.
+#check: $()let _ = s.write_intrinsics();
+#nextln: $()Function "write_intrinsics" writes to the storage.
+#check: $()let _ = s.clear_intrinsic();
+#nextln: $()Function "clear_intrinsic" writes to the storage.
+
+#check: $()7 errors.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/Forc.lock
deleted file mode 100644
index ee5bae6d670..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/Forc.lock
+++ /dev/null
@@ -1,13 +0,0 @@
-[[package]]
-name = 'core'
-source = 'path+from-root-961CA6069E122CF6'
-
-[[package]]
-name = 'raw_slice_ret'
-source = 'member'
-dependencies = ['std']
-
-[[package]]
-name = 'std'
-source = 'path+from-root-961CA6069E122CF6'
-dependencies = ['core']
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/src/main.sw
deleted file mode 100644
index 6aeb3e91093..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/src/main.sw
+++ /dev/null
@@ -1,12 +0,0 @@
-script;
-
-struct HasRawSlice {
-    slice: raw_slice,
-}
-
-fn main() -> HasRawSlice {
-    let val = HasRawSlice {
-        slice: asm() { zero: raw_slice }
-    };
-    val
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/test.toml
deleted file mode 100644
index 168033aa9ed..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/test.toml
+++ /dev/null
@@ -1,4 +0,0 @@
-category = "fail"
-
-# check: fn main() -> HasRawSlice {
-# nextln: $()Returning a type containing `raw_slice` from `main()` is not allowed. Consider converting it into a flat `raw_slice` first
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_calls/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_calls/test.toml
index a8f5ea67fc5..aeca86a984a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_calls/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_calls/test.toml
@@ -6,3 +6,5 @@ category = "fail"
 # check: $()Function d is recursive via e and f, which is unsupported at this time.
 # check: $()Function e is recursive via f and d, which is unsupported at this time.
 # check: $()Function f is recursive via d and e, which is unsupported at this time.
+
+# check: $()6 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/Forc.lock
new file mode 100644
index 00000000000..331d658a292
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_associated"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/Forc.toml
new file mode 100644
index 00000000000..27cbd02415f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_associated"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/src/main.sw
new file mode 100644
index 00000000000..30579eb4ae9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/src/main.sw
@@ -0,0 +1,13 @@
+library;
+
+struct S {}
+
+// TODO: Uncomment this code, and enable this test and add checks once https://github.com/FuelLabs/sway/issues/6537 is fixed.
+impl S {
+    // const A: u8 = Self::B;
+    // const B: u8 = Self::A;
+
+    // const X: u8 = Self::Y;
+    // const Y: u8 = Self::Z;
+    // const Z: u8 = Self::X;
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/test.toml
new file mode 100644
index 00000000000..2b2d5ea7f55
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated/test.toml
@@ -0,0 +1 @@
+category = "disabled" # TODO: Enable this test and add checks once https://github.com/FuelLabs/sway/issues/6537 is fixed.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/Forc.lock
new file mode 100644
index 00000000000..57a80573413
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_associated_over_associated_function"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/Forc.toml
new file mode 100644
index 00000000000..1fc0f96f59e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_associated_over_associated_function"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/src/main.sw
new file mode 100644
index 00000000000..5c403b1f0d1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/src/main.sw
@@ -0,0 +1,13 @@
+library;
+
+struct S {}
+
+impl S {
+    fn assoc() -> u8 {
+        Self::S_ASSOC
+    }
+}
+
+impl S {
+    const S_ASSOC: u8 = Self::assoc();
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/test.toml
new file mode 100644
index 00000000000..3144024dde2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_associated_function/test.toml
@@ -0,0 +1,9 @@
+category = "fail"
+
+#check: $()Self::S_ASSOC
+#nextln: $()Could not find symbol "S_ASSOC" in this scope.
+
+#check: $()const S_ASSOC: u8 = Self::assoc();
+#nextln: $()No method named "assoc" found for type "S".
+
+#check: $()2 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/Forc.lock
new file mode 100644
index 00000000000..9905a4a2526
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_associated_over_module_function"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/Forc.toml
new file mode 100644
index 00000000000..7e6e1257169
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_associated_over_module_function"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/src/main.sw
new file mode 100644
index 00000000000..2db4ae55ca8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/src/main.sw
@@ -0,0 +1,11 @@
+library;
+
+struct S {}
+
+fn mod_fn() -> u8 {
+    S::S_ASSOC
+}
+
+impl S {
+    const S_ASSOC: u8 = mod_fn();
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/test.toml
new file mode 100644
index 00000000000..de7f57c0bf4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_associated_over_module_function/test.toml
@@ -0,0 +1 @@
+category = "disabled" # TODO: Enable this failing test and write checks once https://github.com/FuelLabs/sway/issues/6539 is fixed. 
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/Forc.lock
new file mode 100644
index 00000000000..3a8caa0b5d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_module"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/Forc.toml
new file mode 100644
index 00000000000..ed69431166e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_module"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/src/main.sw
new file mode 100644
index 00000000000..bf0ca9d7edb
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/src/main.sw
@@ -0,0 +1,8 @@
+library;
+
+pub const A: u8 = B;
+pub const B: u8 = A;
+
+pub const X: u8 = Y;
+pub const Y: u8 = Z;
+pub const Z: u8 = X;
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/test.toml
new file mode 100644
index 00000000000..1d3b404a92e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module/test.toml
@@ -0,0 +1,10 @@
+category = "fail" # TODO: Adjust these checks once https://github.com/FuelLabs/sway/issues/6534 is fixed.
+
+# check: $()Type B is recursive via A, which is unsupported at this time.
+# check: $()Type A is recursive via B, which is unsupported at this time.
+
+# check: $()Type Y is recursive via Z and X, which is unsupported at this time.
+# check: $()Type Z is recursive via X and Y, which is unsupported at this time.
+# check: $()Type X is recursive via Y and Z, which is unsupported at this time.
+
+# check: $()5 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/Forc.lock
new file mode 100644
index 00000000000..51cd377d79c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_module_over_associated_const"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/Forc.toml
new file mode 100644
index 00000000000..c41fbc8b663
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_module_over_associated_const"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/src/main.sw
new file mode 100644
index 00000000000..ce072321d46
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/src/main.sw
@@ -0,0 +1,9 @@
+library;
+
+struct S {}
+
+impl S {
+    const S_ASSOC: u8 = MOD_CONST;
+}
+
+const MOD_CONST: u8 = S::S_ASSOC;
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/test.toml
new file mode 100644
index 00000000000..85c1690eb6d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_const/test.toml
@@ -0,0 +1,11 @@
+category = "fail"
+
+#check: $()error
+#check: $()const MOD_CONST: u8 = S::S_ASSOC;
+#nextln: $()Could not find symbol "S_ASSOC" in this scope.
+
+#check: $()error
+#check: $()const MOD_CONST: u8 = S::S_ASSOC;
+#nextln: $()Could not evaluate initializer to a const declaration.
+
+#check: $()2 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/Forc.lock
new file mode 100644
index 00000000000..06c0bad09c9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_module_over_associated_function"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/Forc.toml
new file mode 100644
index 00000000000..67408d6a564
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_module_over_associated_function"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/src/main.sw
new file mode 100644
index 00000000000..aff5abd7e03
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/src/main.sw
@@ -0,0 +1,11 @@
+library;
+
+struct S {}
+
+impl S {
+    fn assoc() -> u8 {
+        MOD_CONST
+    }
+}
+
+const MOD_CONST: u8 = S::assoc();
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/test.toml
new file mode 100644
index 00000000000..40c88a01149
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_associated_function/test.toml
@@ -0,0 +1,9 @@
+category = "fail"
+
+#check: $()const MOD_CONST: u8 = S::assoc();
+#nextln: $()No method named "assoc" found for type "S".
+
+#check: $()const MOD_CONST: u8 = S::assoc();
+#nextln: $()Could not evaluate initializer to a const declaration.
+
+#check: $()2 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/Forc.lock
new file mode 100644
index 00000000000..c89fb4b5ade
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_module_over_module_function"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/Forc.toml
new file mode 100644
index 00000000000..20e75b9fb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_module_over_module_function"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/src/main.sw
new file mode 100644
index 00000000000..ec0d5836e7d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/src/main.sw
@@ -0,0 +1,7 @@
+library;
+
+fn mod_fn() -> u8 {
+    MOD_CONST
+}
+
+const MOD_CONST: u8 = mod_fn();
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/test.toml
new file mode 100644
index 00000000000..d1aa1e8d491
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_module_over_module_function/test.toml
@@ -0,0 +1,11 @@
+category = "fail"
+
+#check: $()error
+#check: $()const MOD_CONST: u8 = mod_fn();
+#nextln: $()Could not find symbol "mod_fn" in this scope.
+
+#check: $()error
+#check: $()const MOD_CONST: u8 = mod_fn();
+#nextln: $()Could not evaluate initializer to a const declaration.
+
+#check: $()2 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/Forc.lock
new file mode 100644
index 00000000000..0761e4748aa
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "recursive_const_stack_overflow"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/Forc.toml
new file mode 100644
index 00000000000..e553c26024b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+name = "recursive_const_stack_overflow"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/src/main.sw
new file mode 100644
index 00000000000..64eb369b581
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/src/main.sw
@@ -0,0 +1,17 @@
+// This test proves that https://github.com/FuelLabs/sway/issues/6540 is fixed.
+
+library;
+
+pub const MOD_FN: u8 = mod_fn();
+
+fn mod_fn() -> u8 {
+    MOD_FN
+}
+
+struct S {}
+
+impl S {
+    const S_ASSOC: u8 = MOD_CONST;
+}
+
+const MOD_CONST: u8 = S::S_ASSOC;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/test.toml
new file mode 100644
index 00000000000..245bc04d534
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_const_stack_overflow/test.toml
@@ -0,0 +1 @@
+category = "disabled" # TODO: Enable this failing test and write checks once https://github.com/FuelLabs/sway/issues/6540 is fixed.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/src/main.sw
index 21da4d7f364..32cc581c2d1 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/src/main.sw
@@ -1,11 +1,7 @@
-script;
+library;
 
 enum E {
     Eins: bool,
     Zwei: u64,
     Drei: E,
 }
-
-fn main() {
-
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/test.toml
index bd9a57f4949..94bb18cf069 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_enum/test.toml
@@ -1,3 +1,5 @@
 category = "fail"
 
 # check: $()recursive types are not supported
+
+# check: $()1 error.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/src/main.sw
index 64b810ce1c1..9cd4a167c94 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/src/main.sw
@@ -1,11 +1,7 @@
-script;
+library;
 
 struct S {
   Eins: bool,
   Zwei: u64,
   Drei: S,
 }
-
-fn main() {
-
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/test.toml
index bd9a57f4949..94bb18cf069 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_struct/test.toml
@@ -1,3 +1,5 @@
 category = "fail"
 
 # check: $()recursive types are not supported
+
+# check: $()1 error.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/src/main.sw
index 5466d0f01e6..cfb73b6a9a7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/src/main.sw
@@ -1,4 +1,4 @@
-script;
+library;
 
 enum E {
     Eins: F,
@@ -39,7 +39,3 @@ enum Y {
 struct Z {
     five: X,
 }
-
-fn main() {
-
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/test.toml
index 144ac44e200..925351b894a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_chain/test.toml
@@ -10,3 +10,5 @@ category = "fail"
 # check: $()Type Y is recursive via Z and X, which is unsupported at this time.
 # check: $()Type Z is recursive via X and Y, which is unsupported at this time.
 # check: $()Type X is recursive via Y and Z, which is unsupported at this time.
+
+# check: $()10 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/src/main.sw
index c8a730d9fb2..4b8ef28f285 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/src/main.sw
@@ -1,4 +1,4 @@
-script;
+library;
 
 enum MyOption<T> {
     Some: T,
@@ -13,5 +13,5 @@ fn bar<V>(value: V) -> MyOption<V> {
 }
 
 fn main() {
-    let x = bar(false);
+    let _ = bar(false);
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/test.toml
index 48b8108e7a9..ba0b96c153a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/recursive_type_unification/test.toml
@@ -1,8 +1,17 @@
 category = "fail"
 
+# check: $()error
+# check: $()MyOption::Some::<V>(foo::<V>(value))
+# nextln: $()Mismatched types.
+# nextln: $()expected: V
+# nextln: $()found:    MyOption<V>.
+# nextln: $()Function return type does not match up with local type annotation.
+
 # check: $()error
 # check: $()MyOption::Some::<V>(foo::<V>(value))
 # nextln: $()Mismatched types.
 # nextln: $()expected: V
 # nextln: $()found:    MyOption<V>.
 # nextln: $()Implicit return must match up with block's type.
+
+# check: $()2 errors.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/Forc.lock
similarity index 56%
rename from test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/Forc.lock
index 74d829edea7..3fc7b0496ff 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/Forc.lock
@@ -1,16 +1,16 @@
 [[package]]
-name = "const-instead-of-let"
+name = "core"
+source = "path+from-root-EA042F5351E6BA99"
+
+[[package]]
+name = "return_path_analysis"
 source = "member"
 dependencies = [
     "core",
     "std",
 ]
 
-[[package]]
-name = "core"
-source = "path+from-root-8953E158C7D5F73E"
-
 [[package]]
 name = "std"
-source = "path+from-root-8953E158C7D5F73E"
+source = "path+from-root-EA042F5351E6BA99"
 dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/Forc.toml
new file mode 100644
index 00000000000..20181921672
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "return_path_analysis"
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
+std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/json_abi_oracle.json
new file mode 100644
index 00000000000..fe51488c706
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/json_abi_oracle.json
@@ -0,0 +1 @@
+[]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/src/main.sw
new file mode 100644
index 00000000000..4e40cf402b3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/src/main.sw
@@ -0,0 +1,567 @@
+script;
+
+// Shows that https://github.com/FuelLabs/sway/issues/6369 has been resolved.
+//
+// The depth of the return path analysis was limited to 50, which meant that there was no
+// requirement to return a value after 50 blocks.
+
+fn f() -> bool {
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+    if true {
+	return true;
+    } else {
+	return false;
+    };
+
+    // No value returned here. The return path analysis should report an error, even though the 
+}
+
+
+// Check that return path analysis is applied to local impl methods.
+fn g() -> bool {
+
+    struct X {
+        y: bool,
+    }
+
+    impl core::ops::Eq for X {
+        fn eq(self, other: Self) -> bool {
+	    if true {
+		return true;
+	    } else {
+		return false;
+	    };
+        }
+    }
+
+    let x = X { y : false };
+    let y = X { y : true } ;
+
+    x == y
+}
+
+// Check that return path analysis is applied to local functions.
+// Local functions are currently not supported, but once they are added this test should fail for
+// the same reason as for the local impl in the function g().
+fn h() -> bool {
+
+    fn tester(other: bool) -> bool {
+	if true {
+	    return true;
+	} else {
+	    return false;
+	};
+    }
+
+    tester(true)
+}
+
+fn main() {
+    let _ = f();
+    let _ = g();
+    let _ = h();
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/test.toml
new file mode 100644
index 00000000000..1d5eb2f08b5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/return_path_analysis/test.toml
@@ -0,0 +1,9 @@
+category = "fail"
+
+# check: $()Declaring nested functions is currently not implemented.
+# check: $()Could not find symbol "tester" in this scope.
+# check: $()This path must return a value of type "bool" from function "f", but it does not.
+# check: $()This path must return a value of type "bool" from function "eq", but it does not.
+# check: $()Aborting due to 4 errors.
+
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadow_import/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadow_import/test.toml
index 0370f2374de..3d004670c3c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/shadow_import/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadow_import/test.toml
@@ -1,4 +1,4 @@
 category = "fail"
 
-# check: $()The imported symbol "Foo" shadows another symbol with the same name.
-# check: $()The imported symbol "Bar2" shadows another symbol with the same name.
+# check: $()Imported symbol "Foo" shadows another symbol of the same name.
+# check: $()Imported symbol "Bar2" shadows another symbol of the same name.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/Forc.lock
new file mode 100644
index 00000000000..f1e5fe7934c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-64A912F71AFE52EA"
+
+[[package]]
+name = "shadowed_configurables"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/Forc.toml
similarity index 82%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/Forc.toml
index ea850965191..1cbcb5f14b7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/Forc.toml
@@ -1,9 +1,9 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
-license = "Apache-2.0"
-name = "associated_const_trait_const"
 implicit-std = false
+license = "Apache-2.0"
+name = "shadowed_configurables"
 
 [dependencies]
 core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/src/lib.sw
new file mode 100644
index 00000000000..1b41f86d27d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/src/lib.sw
@@ -0,0 +1,7 @@
+library;
+
+pub const LIB_X = 5;
+
+pub const LIB_Y = 5;
+
+pub const LIB_Z = 5;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/src/main.sw
new file mode 100644
index 00000000000..5bca5a5c105
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/src/main.sw
@@ -0,0 +1,49 @@
+script;
+
+mod lib;
+
+const CONST_A: u8 = 1;
+
+use lib::LIB_X;
+
+configurable {
+    X: u8 = 10,
+    Y: u8 = 11,
+    A: u8 = 13,
+    B: u8 = 14,
+    CONST_A: u8 = 15,
+    CONST_B: u8 = 16,
+    LIB_X: u8 = 17,
+    LIB_Y: u8 = 18,
+    LIB_Z_ALIAS: u8 = 19,
+    LET_A: u8 = 20,
+    LET_B: u8 = 21,
+    LET_C: u8 = 22,
+}
+
+const CONST_B: u8 = 2;
+
+use lib::LIB_Y;
+
+use lib::LIB_Z as LIB_Z_ALIAS;
+
+struct S {
+    x: u8,
+}
+
+enum E {
+    A: u8,
+}
+
+fn main() {
+    let X = 101u8;
+    const Y: u8 = 102;
+
+    {
+        let A = 103u8;
+        const B: u8 = 104;
+    }
+
+    let S { x: LET_A } = S { x: 105 };
+    let (_, LET_B) = (106u8, 107u8);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/test.toml
new file mode 100644
index 00000000000..a3ef69266b2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables/test.toml
@@ -0,0 +1,84 @@
+category = "fail"
+
+#check: $()error
+#sameln: $()Constant of the same name as configurable already exists
+#check: $()const CONST_A: u8 = 1;
+#nextln: $()Constant "CONST_A" is declared here.
+#check: $()CONST_A: u8 = 15,
+#nextln: $()Configurable "CONST_A" has the same name as an already declared constant.
+
+#check: $()error
+#sameln: $()Constant of the same name as configurable already exists
+#check: $()use lib::LIB_X;
+#nextln: $()Constant "LIB_X" is declared here.
+#check: $()LIB_X: u8 = 17,
+#nextln: $()Configurable "LIB_X" has the same name as an already declared constant.
+
+#check: $()error
+#sameln: $()Constant of the same name as configurable already exists
+#check: $()LIB_Y: u8 = 18,
+#nextln: $()Configurable "LIB_Y" has the same name as an already declared constant.
+#check: $()use lib::LIB_Y;
+#nextln: $()Constant "LIB_Y" is declared here.
+
+#check: $()error
+#sameln: $()Constant of the same name as configurable already exists
+#check: $()LIB_Z_ALIAS: u8 = 19,
+#nextln: $()Configurable "LIB_Z_ALIAS" has the same name as an already declared constant.
+#check: $()use lib::LIB_Z as LIB_Z_ALIAS;
+#nextln: $()Constant "LIB_Z_ALIAS" is declared here.
+
+#check: $()error
+#sameln: $()Configurable of the same name as constant already exists
+#check: $()CONST_B: u8 = 16,
+#nextln: $()Configurable "CONST_B" is declared here.
+#check: $()const CONST_B: u8 = 2;
+#nextln: $()Constant "CONST_B" has the same name as an already declared configurable.
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()X: u8 = 10,
+#nextln: $()Shadowed configurable "X" is declared here.
+#check: $()let X = 101u8;
+#nextln: $()Variable "X" shadows configurable of the same name.
+#check: $()Consider renaming either the variable "X" or the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()Y: u8 = 11,
+#nextln: $()Shadowed configurable "Y" is declared here.
+#check: $()const Y: u8 = 102;
+#nextln: $()Constant "Y" shadows configurable of the same name.
+#check: $()Consider renaming either the constant "Y" or the configurable "Y".
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()A: u8 = 13,
+#nextln: $()Shadowed configurable "A" is declared here.
+#check: $()let A = 103u8;
+#nextln: $()Variable "A" shadows configurable of the same name.
+#check: $()Consider renaming either the variable "A" or the configurable "A".
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()B: u8 = 14,
+#nextln: $()Shadowed configurable "B" is declared here.
+#check: $()const B: u8 = 104;
+#nextln: $()Constant "B" shadows configurable of the same name.
+#check: $()Consider renaming either the constant "B" or the configurable "B".
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()LET_A: u8 = 20,
+#nextln: $()Shadowed configurable "LET_A" is declared here.
+#check: $()let S { x: LET_A } = S { x: 105 };
+#nextln: $()Variable "LET_A" shadows configurable of the same name.
+#check: $()Consider renaming either the variable "LET_A" or the configurable "LET_A".
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()LET_B: u8 = 21,
+#nextln: $()Shadowed configurable "LET_B" is declared here.
+#check: $()let (_, LET_B) = (106u8, 107u8);
+#nextln: $()Variable "LET_B" shadows configurable of the same name.
+#check: $()Consider renaming either the variable "LET_B" or the configurable "LET_B".
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/Forc.lock
new file mode 100644
index 00000000000..ed28297caaf
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-8D5D4F6C9D8606CC"
+
+[[package]]
+name = "shadowed_configurables_in_pattern_matching"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/Forc.toml
new file mode 100644
index 00000000000..82f3d90af2d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+implicit-std = false
+license = "Apache-2.0"
+name = "shadowed_configurables_in_pattern_matching"
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/src/main.sw
new file mode 100644
index 00000000000..f6d669db681
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/src/main.sw
@@ -0,0 +1,50 @@
+script;
+
+enum E {
+    V: (u8, u8, u8),
+}
+
+struct S {
+    x: u8,
+    y: u8,
+    z: u8,
+}
+
+struct SConfig {
+    CONFIG: u8,
+}
+
+configurable {
+    X: u8 = 10,
+    Y: u8 = 11,
+    Z: u8 = 12,
+    CONFIG: u8 = 13,
+}
+
+fn main() {
+    let _ = match 42 {
+        X => 101,
+    };
+
+    let e = E::V((100, 100, 100));
+    let _ = match e {
+        E::V((_, X, _)) => 101,
+        E::V((X, Y, Z)) => 102,
+        E::V((X, _, _)) | E::V((_, _, X)) => 103,
+    };
+
+    let s = S { x: 100, y: 100, z: 100 };
+    let _ = match s {
+        S { x: X, .. } => 101,
+        S { y: X, .. } => 102,
+        S { x: X, y: Y, z: Z } => 103,
+        S { x: X, .. } | S { z: X, .. } => 104,
+    };
+
+    let s = SConfig { CONFIG: 100 };
+    let _ = match s {
+        SConfig { CONFIG } => 101,
+        SConfig { CONFIG: CONFIG } => 102,
+        SConfig { CONFIG: CONFIG } | SConfig { CONFIG } => 103,
+    };
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/test.toml
new file mode 100644
index 00000000000..a9ea6d12ce2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_configurables_in_pattern_matching/test.toml
@@ -0,0 +1,149 @@
+category = "fail"
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()X => 101,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()E::V((_, X, _)) => 101,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()E::V((X, Y, Z)) => 102,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()Y: u8 = 11,
+#nextln: $()Configurable "Y" is declared here.
+#check: $()E::V((X, Y, Z)) => 102,
+#nextln: $()"Y" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "Y"?
+#check: $()or consider renaming the configurable "Y".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()Z: u8 = 12,
+#nextln: $()Configurable "Z" is declared here.
+#check: $()E::V((X, Y, Z)) => 102,
+#nextln: $()"Z" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "Z"?
+#check: $()or consider renaming the configurable "Z".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()E::V((X, _, _)) | E::V((_, _, X)) => 103,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#not: $()E::V((X, _, _)) | E::V((_, _, X)) => 101,
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()S { x: X, .. } => 101,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()S { y: X, .. } => 102,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()S { x: X, y: Y, z: Z } => 103,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()Y: u8 = 11,
+#nextln: $()Configurable "Y" is declared here.
+#check: $()S { x: X, y: Y, z: Z } => 103,
+#nextln: $()"Y" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "Y"?
+#check: $()or consider renaming the configurable "Y".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()Z: u8 = 12,
+#nextln: $()Configurable "Z" is declared here.
+#check: $()S { x: X, y: Y, z: Z } => 103,
+#nextln: $()"Z" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "Z"?
+#check: $()or consider renaming the configurable "Z".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()X: u8 = 10,
+#nextln: $()Configurable "X" is declared here.
+#check: $()S { x: X, .. } | S { z: X, .. } => 104,
+#nextln: $()"X" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "X"?
+#check: $()or consider renaming the configurable "X".
+
+#not: $()S { x: X, .. } | S { z: X, .. } => 104,
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()CONFIG: u8 = 13,
+#nextln: $()Shadowed configurable "CONFIG" is declared here.
+#check: $()SConfig { CONFIG } => 101,
+#nextln: $()Pattern variable "CONFIG" shadows configurable of the same name.
+#nextln: $()"CONFIG" is a struct field that defines a pattern variable of the same name.
+#check: $()To rename the pattern variable use the `:`. E.g.: `CONFIG: some_other_name`.
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()CONFIG: u8 = 13,
+#nextln: $()Configurable "CONFIG" is declared here.
+#check: $()SConfig { CONFIG: CONFIG } => 102,
+#nextln: $()"CONFIG" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "CONFIG"?
+#check: $()or consider renaming the configurable "CONFIG".
+
+#check: $()error
+#sameln: $()Configurables cannot be matched against
+#check: $()CONFIG: u8 = 13,
+#nextln: $()Configurable "CONFIG" is declared here.
+#check: $()SConfig { CONFIG: CONFIG } | SConfig { CONFIG } => 103,
+#nextln: $()"CONFIG" is a configurable and configurables cannot be matched against.
+#nextln: $()Are you trying to define a pattern variable named "CONFIG"?
+#check: $()or consider renaming the configurable "CONFIG".
+
+#check: $()error
+#sameln: $()Configurables cannot be shadowed
+#check: $()CONFIG: u8 = 13,
+#nextln: $()Shadowed configurable "CONFIG" is declared here.
+#check: $()SConfig { CONFIG: CONFIG } | SConfig { CONFIG } => 103,
+#nextln: $()Pattern variable "CONFIG" shadows configurable of the same name.
+#nextln: $()"CONFIG" is a struct field that defines a pattern variable of the same name.
+#check: $()To rename the pattern variable use the `:`. E.g.: `CONFIG: some_other_name`.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/src/main.sw
index 3af2f1d8970..1e0589c8a72 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/src/main.sw
@@ -21,6 +21,14 @@ const M_Z = 41;
 use lib::L_Y;
 use lib::L_Z;
 
+use lib::L_Z as L_Z_ALIAS;
+
+struct StructWithConstNames {
+    M_X: u64,
+    L_Y: u64,
+    L_Z_ALIAS: u64,
+}
+
 fn main() {
     // local const shadowing a module const
     const M_Y = 5;
@@ -96,6 +104,19 @@ fn main() {
     // const shadowing a locally imported const
     use lib::L_M;
     const L_M = 15;
+
+    let s = StructWithConstNames {
+        M_X,
+        L_Y,
+        L_Z_ALIAS,
+    };
+
+    // pattern variables shadowing different types of consts
+    let _ = match s {
+        StructWithConstNames { M_X, L_Y, L_Z_ALIAS } => {
+            42
+        },
+    };
 }
 
 use lib::L_N;
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/test.toml
index d85b81a3f8d..ed23a889182 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars/test.toml
@@ -1,51 +1,49 @@
 category = "fail"
 
 #check: $()error
-
 #check: $()use lib::L_A;
 #nextln: $()use lib::L_A;
-#nextln: $()The imported symbol "L_A" shadows another symbol with the same name.
+#nextln: $()Imported symbol "L_A" shadows another symbol of the same name.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()use lib::L_X;
+#nextln: $()Constant "L_X" is already declared here.
 #check: $()const L_X = 1;
-#nextln: $()Constant "L_X" was already defined in scope.
+#nextln: $()Constant "L_X" has the same name as an already declared constant.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
 #check: $()const M_X = 2;
+#nextln: $()Constant "M_X" is already declared here.
 #nextln: $()const M_X = 3;
-#nextln: $()Constant "M_X" was already defined in scope.
+#nextln: $()Constant "M_X" has the same name as an already declared constant.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const M_Y = 4;
 #nextln: $()Shadowed constant "M_Y" is declared here.
-
 #check: $()const M_Y = 5;
 #nextln: $()Constant "M_Y" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const M_Y = 5;
 #nextln: $()Shadowed constant "M_Y" is declared here.
-
 #check: $()const M_Y = 55;
 #nextln: $()Constant "M_Y" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()use lib::L_Y;
 #nextln: $()Shadowed constant "L_Y" gets imported here.
-
 #check: $()const L_Y = 6;
 #nextln: $()Constant "L_Y" shadows imported constant of the same name.
-
 #check: $()pub const L_Y = 5;
 #nextln: $()This is the original declaration of the imported constant "L_Y".
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const F_X = 7;
 #nextln: $()Shadowed constant "F_X" is declared here.
 #nextln: $()const F_X = 8;
@@ -53,7 +51,6 @@ category = "fail"
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const F_X = 8;
 #nextln: $()Shadowed constant "F_X" is declared here.
 #check: $()const F_X = 81;
@@ -61,37 +58,29 @@ category = "fail"
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const F_Y = 9;
 #nextln: $()Shadowed constant "F_Y" is declared here.
-
 #check: $()const F_Y = 10;
 #nextln: $()Constant "F_Y" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const L_X = 1;
 #nextln: $()Shadowed constant "L_X" is declared here.
-
 #check: $()let L_X = 100;
 #nextln: $()Variable "L_X" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()use lib::L_X;
 #nextln: $()Shadowed constant "L_X" gets imported here.
-
 #check: $()let L_X = 100;
 #nextln: $()Variable "L_X" shadows imported constant of the same name.
-
 #check: $()pub const L_X = 5;
 #nextln: $()This is the original declaration of the imported constant "L_X".
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const F_Z = 11;
 #nextln: $()Shadowed constant "F_Z" is declared here.
 #nextln: $()let F_Z = 102;
@@ -99,7 +88,6 @@ category = "fail"
 
 #check: $()error
 #sameln: $()Constants cannot shadow variables
-
 #check: $()let F_A = 103;
 #nextln: $()This is the shadowed variable "F_A".
 #nextln: $()const F_A = 12;
@@ -107,108 +95,136 @@ category = "fail"
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const M_Y = 5;
 #nextln: $()Shadowed constant "M_Y" is declared here.
-
 #check: $()let M_Y = 106;
 #nextln: $()Variable "M_Y" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const M_Z = 41;
 #nextln: $()Shadowed constant "M_Z" is declared here.
-
 #check: $()let M_Z = 107;
 #nextln: $()Variable "M_Z" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot shadow variables
-
 #check: $()let B = 108;
 #nextln: $()This is the shadowed variable "B".
-
 #check: $()const B = 13;
 #nextln: $()Constant "B" shadows variable of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const F_K = 14;
 #nextln: $()Shadowed constant "F_K" is declared here.
-
 #check: $()let F_K = 109;
 #nextln: $()Variable "F_K" shadows constant of the same name.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()use lib::L_Z;
 #nextln: $()Shadowed constant "L_Z" gets imported here.
-
 #check: $()let L_Z = 110;
 #nextln: $()Variable "L_Z" shadows imported constant of the same name.
-
 #check: $()pub const L_Z = 5;
 #nextln: $()This is the original declaration of the imported constant "L_Z".
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()use lib::L_K;
 #nextln: $()Shadowed constant "L_K" gets imported here.
-
 #check: $()let L_K = 111;
 #nextln: $()Variable "L_K" shadows imported constant of the same name.
-
 #check: $()pub const L_K = 5;
 #nextln: $()This is the original declaration of the imported constant "L_K".
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()use lib::L_M;
 #nextln: $()Shadowed constant "L_M" gets imported here.
-
 #check: $()const L_M = 15;
 #nextln: $()Constant "L_M" shadows imported constant of the same name.
-
 #check: $()pub const L_M = 5;
 #nextln: $()This is the original declaration of the imported constant "L_M".
 
+#check: $()error
+#sameln: $()Constants cannot be shadowed
+#check: $()const M_X = 3;
+#nextln: $()Shadowed constant "M_X" is declared here.
+#check: $()StructWithConstNames { M_X, L_Y, L_Z_ALIAS } => {
+#nextln: $()Variable "M_X" shadows constant of the same name.
+
+#check: $()error
+#sameln: $()Constants cannot be shadowed
+#check: $()use lib::L_Y;
+#nextln: $()Shadowed constant "L_Y" gets imported here.
+#check: $()StructWithConstNames { M_X, L_Y, L_Z_ALIAS } => {
+#nextln: $()Variable "L_Y" shadows imported constant of the same name.
+#check: $()pub const L_Y = 5;
+#nextln: $()This is the original declaration of the imported constant "L_Y".
+
+#check: $()error
+#sameln: $()Constants cannot be shadowed
+#check: $()use lib::L_Z as L_Z_ALIAS;
+#nextln: $()Shadowed constant "L_Z_ALIAS" gets imported here as alias.
+#check: $()StructWithConstNames { M_X, L_Y, L_Z_ALIAS } => {
+#nextln: $()Variable "L_Z_ALIAS" shadows imported constant of the same name.
+#check: $()pub const L_Z = 5;
+#nextln: $()This is the original declaration of the imported constant "L_Z_ALIAS".
+
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()const S_X = 200;
+#nextln: $()Constant "S_X" is already declared here.
 #check: $()const S_X = 201;
-#nextln: $()Constant "S_X" was already defined in scope.
+#nextln: $()Constant "S_X" has the same name as an already declared constant.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()use lib::L_N;
+#nextln: $()Constant "L_N" is already declared here.
 #check: $()const L_N = 202;
-#check: $()Constant "L_N" was already defined in scope.
+#nextln: $()Constant "L_N" has the same name as an already declared constant.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()const M_M = 16;
+#nextln: $()Constant "M_M" is already declared here.
 #check: $()const M_M = 203;
-#check: $()Constant "M_M" was already defined in scope.
+#nextln: $()Constant "M_M" has the same name as an already declared constant.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const S_Y = 204;
 #nextln: $()Shadowed constant "S_Y" is declared here.
-
 #check: $()const S_Y = 205;
 #nextln: $()Constant "S_Y" shadows constant of the same name.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()const E_X = 300;
+#nextln: $()Constant "E_X" is already declared here.
 #check: $()const E_X = 301;
-#nextln: $()Constant "E_X" was already defined in scope.
+#nextln: $()Constant "E_X" has the same name as an already declared constant.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()use lib::L_N;
+#nextln: $()Constant "L_N" is already declared here.
 #check: $()const L_N = 302;
-#check: $()Constant "L_N" was already defined in scope.
+#nextln: $()Constant "L_N" has the same name as an already declared constant.
 
+#check: $()error
+#sameln: $()Constant of the same name already exists
+#check: $()const M_M = 16;
+#nextln: $()Constant "M_M" is already declared here.
 #check: $()const M_M = 303;
-#check: $()Constant "M_M" was already defined in scope.
+#nextln: $()Constant "M_M" has the same name as an already declared constant.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
-
 #check: $()const E_Y = 304;
 #nextln: $()Shadowed constant "E_Y" is declared here.
-
 #check: $()const E_Y = 305;
-#nextln: $()Constant "E_Y" shadows constant of the same name.
+#nextln: $()Constant "E_Y" shadows constant of the same name.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars_alias/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars_alias/test.toml
index 0d7bafcd27b..47228488d82 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars_alias/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/shadowing/shadowed_consts_and_vars_alias/test.toml
@@ -1,9 +1,11 @@
 category = "fail"
 
 #check: $()error
-
+#sameln: $()Constant of the same name already exists
+#check: $()use lib::X as Y;
+#nextln: $()Constant "Y" is already declared here.
 #check: $()const Y = 7;
-#nextln: $()Constant "Y" was already defined in scope.
+#nextln: $()Constant "Y" has the same name as an already declared constant.
 
 #check: $()error
 #sameln: $()Constants cannot be shadowed
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/Forc.lock
similarity index 54%
rename from test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/Forc.lock
index 6c6fcaa3174..c5bc5415952 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/Forc.lock
@@ -1,8 +1,8 @@
 [[package]]
 name = "core"
-source = "path+from-root-9B49BFF20742B6CF"
+source = "path+from-root-53D6DC514F06A250"
 
 [[package]]
-name = "str_slice_script"
+name = "slice_intrinsics"
 source = "member"
 dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/Forc.toml
similarity index 86%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/Forc.toml
index aa9fe21ccae..011fe1ab735 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/Forc.toml
@@ -2,7 +2,7 @@
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "str_slice"
+name = "slice_intrinsics"
 
 [dependencies]
 core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_fail/const-instead-of-let/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..aab161b0506
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/src/main.sw
new file mode 100644
index 00000000000..e982f253c65
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/src/main.sw
@@ -0,0 +1,55 @@
+script;
+
+// slice cannot be consts
+const GLOBAL_ARRAY: [u64; 5] = [1, 2, 3, 4, 5];
+const GLOBAL_SLICE: &__slice[u64] = __slice(&GLOBAL_ARRAY, 0, 5);
+
+fn main()  {
+    type_check();
+
+    // slice cannot be consts
+    const LOCAL_ARRAY: [u64; 5] = [1, 2, 3, 4, 5];
+    const LOCAL_SLICE: &__slice[u64] = __slice(&LOCAL_ARRAY, 0, 5);
+
+    // Wrong start index
+    let a: [u64; 5] = [1, 2, 3, 4, 5];
+    let _ = __slice(&a, 6, 7);
+
+    // Wrong end index
+    let a: [u64; 5] = [1, 2, 3, 4, 5];
+    let _ = __slice(&a, 0, 6);
+
+    // Wrong first argument
+    __slice(0, 0, 0);
+
+    // Wrong start index
+    __slice(&a, "", 0);
+
+    // Wrong end index
+    __slice(&a, 0, "");
+
+    let a: [u64; 5] = [1, 2, 3, 4, 5];
+    let s: &__slice[u64] = __slice(&LOCAL_ARRAY, 0, 5);
+
+    // Wrong first argument
+    __elem_at(0, 0);
+
+    // Wrong index type
+    __elem_at(&a, "");
+
+    // Wrong index type
+    __elem_at(s, "");
+}
+
+fn type_check() {
+    // Cannot get mut ref from an immutable array
+    let immutable_array: [u64; 5] = [1, 2, 3, 4, 5];
+    let _: &mut u64 = __elem_at(&immutable_array, 0);
+
+    // Cannot get mut slice from an immutable array
+    let _: &mut __slice[u64] = __slice(&immutable_array, 0, 5);
+
+    // Cannot get mut ref from an immutable slice
+    let immutable_slice: &__slice[u64] = __slice(&immutable_array, 0, 5);
+    let _: &mut u64 = __elem_at(immutable_slice, 0);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/test.toml
new file mode 100644
index 00000000000..3d87b130111
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/slice/slice_intrinsics/test.toml
@@ -0,0 +1,54 @@
+category = "fail"
+
+# check: __elem_at(&immutable_array, 0);
+# nextln: $()Mismatched types.
+# nextln: $()expected: &mut u64
+# nextln: $()found:    &u64
+
+# check: __slice(&immutable_array, 0, 5);
+# nextln: $()Mismatched types.
+# nextln: $()expected: &mut __slice[u64]
+# nextln: $()found:    &__slice[u64]
+
+# check: __elem_at(immutable_slice, 0);
+# nextln: $()Mismatched types.
+# nextln: $()expected: &mut u64
+# nextln: $()found:    &u64
+
+# check: let _ = __slice(&a, 6, 7)
+# nextln: $()Index out of bounds; the length is 5 but the index is 6.
+
+# check: let _ = __slice(&a, 0, 6)
+# nextln: $()Index out of bounds; the length is 5 but the index is 6.
+
+# check: __slice(0, 0, 0)
+# nextln: $()Unsupported argument type to intrinsic "slice"
+
+# check: __slice(&a, "", 0)
+# nextln: $()Mismatched types
+# nextln: $()expected: u64
+# nextln: $()found:    str
+
+# check: __slice(&a, 0, "")
+# nextln: $()Mismatched types
+# nextln: $()expected: u64
+# nextln: $()found:    str
+#
+# check: __elem_at(0, 0);
+# nextln: $()Unsupported argument type to intrinsic "elem_at"
+
+# check: __elem_at(&a, "");
+# nextln: $()Mismatched types.
+# nextln: $()expected: u64
+# nextln: $()found:    str.
+
+# check: __elem_at(s, "");
+# nextln: $()Mismatched types.
+# nextln: $()expected: u64
+# nextln: $()found:    str.
+
+# check: &__slice[u64] = __slice(&GLOBAL_ARRAY, 0, 5)
+# nextln: $()slices or types containing slices on `const` are not allowed
+
+# check: &__slice[u64] = __slice(&LOCAL_ARRAY, 0, 5)
+# nextln: $()slices or types containing slices on `const` are not allowed
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.lock
index 8d57bc1441b..1994ee4c330 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.lock
@@ -2,12 +2,7 @@
 name = "core"
 source = "path+from-root-BB0D5D60D9FB76A1"
 
-[[package]]
-name = "std"
-source = "path+from-root-BB0D5D60D9FB76A1"
-dependencies = ["core"]
-
 [[package]]
 name = "storage_clear_incorrect_purity_annotation"
 source = "member"
-dependencies = ["std"]
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.toml
index 6ab9ffc89f7..fd7eb4ab86d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/Forc.toml
@@ -5,4 +5,4 @@ license = "Apache-2.0"
 name = "storage_clear_incorrect_purity_annotation"
 
 [dependencies]
-std = { path = "../../../../../../sway-lib-std" }
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/src/main.sw
index c498c6f1d9e..b86cacc78ae 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/src/main.sw
@@ -6,6 +6,6 @@ abi MyContract {
 
 impl MyContract for Contract {
     fn test_function() {
-        std::storage::storage_api::clear(0x0000000000000000000000000000000000000000000000000000000000000000);
+        let _ = __state_clear(b256::zero(), 0);
     }
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/test.toml
index 2d0cc28b07b..b4da49e0acb 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_clear_incorrect_purity_annotation/test.toml
@@ -1,3 +1,11 @@
 category = "fail"
 
-#check: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(write)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test_function()
+#nextln: $()Function "test_function" is pure and cannot access storage.
+#check: $()let _ = __state_clear(b256::zero(), 0);
+#nextln: $()Clearing the storage happens here.
+#check: $()Consider declaring the function "test_function" as `#[storage(write)]`
+
+#check: $()1 error.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/Forc.lock
deleted file mode 100644
index d2cbe280e7b..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/Forc.lock
+++ /dev/null
@@ -1,13 +0,0 @@
-[[package]]
-name = 'core'
-source = 'path+from-root-408A0F6A51E5F189'
-
-[[package]]
-name = 'std'
-source = 'path+from-root-408A0F6A51E5F189'
-dependencies = ['core']
-
-[[package]]
-name = 'storage_conflict'
-source = 'member'
-dependencies = ['std']
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/test.toml
deleted file mode 100644
index dcb08e5325b..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/test.toml
+++ /dev/null
@@ -1,49 +0,0 @@
-category = "fail"
-
-# check: storage_conflict/src/main.sw:103:1
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:46:1
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:33:1
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:13:5
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:110:1
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:57:1
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:53:1
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:16:5
-# check: $()This function performs a storage read but does not have the required attribute(s).  Try adding "#[storage(read)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:118:1
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:71:1
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:64:1
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:19:5
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:124:1
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:87:1
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:82:1
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
-
-# check: storage_conflict/src/main.sw:22:5
-# check: $()This function performs a storage write but does not have the required attribute(s).  Try adding "#[storage(write)]" to the function declaration.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_field_access_on_non_struct/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_field_access_on_non_struct/test.toml
index 5fee41678db..a951a9d13c6 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_field_access_on_non_struct/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_field_access_on_non_struct/test.toml
@@ -3,7 +3,7 @@ category = "fail"
 #check: $()Storage field does not exist
 #check: $()let _ = storage.not_in_storage.read();
 #nextln: $()Storage field "not_in_storage" does not exist in the storage.
-#nextln: $()Available storage fields are "b" and "s_01".
+#nextln: $()Available storage fields are "storage.b" and "storage.s_01".
 
 #check: $()Field access requires a struct
 #check: $()let _ = storage.b.prev_not_a_struct.read();
@@ -42,4 +42,4 @@ category = "fail"
 #check: $()Struct field does not exist
 #check: $()let _ = storage.s_01.second.third.non_existing_field.read();
 #check: $()Field "non_existing_field" does not exist in the struct "Struct03".
-#check: $()Only available field is "x".
\ No newline at end of file
+#check: $()Only available field is "x".
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.lock
index c9fecc9c847..e6a2b048916 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
-name = 'storage_ops_in_library'
-source = 'member'
+name = "core"
+source = "path+from-root-5340A91F7729E05D"
+
+[[package]]
+name = "storage_ops_in_library"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.toml
index a4224f898ad..02f7043dfe5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/Forc.toml
@@ -4,3 +4,7 @@ entry = "main.sw"
 license = "Apache-2.0"
 name = "storage_ops_in_library"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/test.toml
index 118b1b04091..3ada048855f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_ops_in_library/test.toml
@@ -1,4 +1,19 @@
 category = "fail"
 
-# check: do_storage::side_effects();
-# nextln: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read, write)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn main()
+#nextln: $()Function "main" is pure and cannot access storage.
+#check: $()do_storage::side_effects();
+#nextln: $()Function "side_effects" reads from and writes to the storage.
+#check: $()Consider declaring the function "main" as `#[storage(read, write)]`
+
+#check: $()srw v is_set key;
+#nextln: $()Contract storage cannot be used in an external context.
+
+#check: $()sww key is_set v;
+
+#check: $()sww key is_set v;
+#nextln: $()Contract storage cannot be used in an external context.
+
+#check: $()3 errors.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/Forc.lock
new file mode 100644
index 00000000000..d083d106abb
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-AB487C347066147A"
+
+[[package]]
+name = "storage_purity_conflict"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/Forc.toml
new file mode 100644
index 00000000000..84569cf591e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+name = "storage_purity_conflict"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/src/main.sw
similarity index 95%
rename from test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/src/main.sw
rename to test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/src/main.sw
index d9cf66c1e19..fae1a32f505 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/src/main.sw
@@ -32,7 +32,7 @@ impl MyContract for Contract {
 
 fn do_impure_stuff_a(choice: bool) -> bool {
     if choice {
-        let s = do_more_impure_stuff_a();
+        let _ = do_more_impure_stuff_a();
         false
     } else {
         true
@@ -55,7 +55,7 @@ fn do_impure_stuff_b() -> bool {
 }
 
 fn do_more_impure_stuff_b() -> bool {
-    let a = read_storage_b256();
+    let _ = read_storage_b256();
     true
 }
 
@@ -80,7 +80,7 @@ enum E {
 }
 
 fn do_impure_stuff_d() -> bool {
-    let a = E::b(do_more_impure_stuff_d());
+    let _ = E::b(do_more_impure_stuff_d());
     true
 }
 
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/test.toml
new file mode 100644
index 00000000000..f02b083598d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/storage_purity_conflict/test.toml
@@ -0,0 +1,131 @@
+category = "fail"
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn read_storage_word() -> u64
+#nextln: $()Function "read_storage_word" is pure and cannot access storage.
+#check: $()srw res is_set key;
+#nextln: $()Reading a word from the storage happens here.
+#check: $()Consider declaring the function "read_storage_word" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_more_impure_stuff_a() -> S
+#nextln: $()Function "do_more_impure_stuff_a" is pure and cannot access storage.
+#check: $()let a = read_storage_word();
+#nextln: $()Function "read_storage_word" reads from the storage.
+#check: $()Consider declaring the function "do_more_impure_stuff_a" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_impure_stuff_a(choice: bool) -> bool
+#nextln: $()Function "do_impure_stuff_a" is pure and cannot access storage.
+#check: $()let _ = do_more_impure_stuff_a();
+#nextln: $()Function "do_more_impure_stuff_a" reads from the storage.
+#check: $()Consider declaring the function "do_impure_stuff_a" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test_function_a() -> bool
+#nextln: $()Function "test_function_a" is pure and cannot access storage.
+#check: $()do_impure_stuff_a(true)
+#nextln: $()Function "do_impure_stuff_a" reads from the storage.
+#check: $()Consider declaring the function "test_function_a" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn read_storage_b256() -> b256
+#nextln: $()Function "read_storage_b256" is pure and cannot access storage.
+#check: $()srwq buf is_set key count;
+#nextln: $()Reading storage slots happens here.
+#check: $()Consider declaring the function "read_storage_b256" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_more_impure_stuff_b() -> bool
+#nextln: $()Function "do_more_impure_stuff_b" is pure and cannot access storage.
+#check: $()let _ = read_storage_b256();
+#nextln: $()Function "read_storage_b256" reads from the storage.
+#check: $()Consider declaring the function "do_more_impure_stuff_b" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_impure_stuff_b() -> bool
+#nextln: $()Function "do_impure_stuff_b" is pure and cannot access storage.
+#check: $()do_more_impure_stuff_b()
+#nextln: $()Function "do_more_impure_stuff_b" reads from the storage.
+#check: $()Consider declaring the function "do_impure_stuff_b" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test_function_b() -> bool
+#nextln: $()Function "test_function_b" is pure and cannot access storage.
+#check: $()do_impure_stuff_b()
+#nextln: $()Function "do_impure_stuff_b" reads from the storage.
+#check: $()Consider declaring the function "test_function_b" as `#[storage(read)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn write_storage_word()
+#nextln: $()Function "write_storage_word" is pure and cannot access storage.
+#check: $()sww key is_set val;
+#nextln: $()Writing a word to the storage happens here.
+#check: $()Consider declaring the function "write_storage_word" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_more_impure_stuff_c()
+#nextln: $()Function "do_more_impure_stuff_c" is pure and cannot access storage.
+#check: $()write_storage_word();
+#nextln: $()Function "write_storage_word" writes to the storage.
+#check: $()Consider declaring the function "do_more_impure_stuff_c" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_impure_stuff_c() -> bool
+#nextln: $()Function "do_impure_stuff_c" is pure and cannot access storage.
+#check: $()do_more_impure_stuff_c();
+#nextln: $()Function "do_more_impure_stuff_c" writes to the storage.
+#check: $()Consider declaring the function "do_impure_stuff_c" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test_function_c() -> bool
+#nextln: $()Function "test_function_c" is pure and cannot access storage.
+#check: $()do_impure_stuff_c()
+#nextln: $()Function "do_impure_stuff_c" writes to the storage.
+#check: $()Consider declaring the function "test_function_c" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn write_storage_b256()
+#nextln: $()Function "write_storage_b256" is pure and cannot access storage.
+#check: $()swwq key is_set val count;
+#nextln: $()Writing to storage slots happens here.
+#check: $()Consider declaring the function "write_storage_b256" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_more_impure_stuff_d() -> bool
+#nextln: $()Function "do_more_impure_stuff_d" is pure and cannot access storage.
+#check: $()write_storage_b256();
+#nextln: $()Function "write_storage_b256" writes to the storage.
+#check: $()Consider declaring the function "do_more_impure_stuff_d" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn do_impure_stuff_d() -> bool
+#nextln: $()Function "do_impure_stuff_d" is pure and cannot access storage.
+#check: $()let _ = E::b(do_more_impure_stuff_d());
+#nextln: $()Function "do_more_impure_stuff_d" writes to the storage.
+#check: $()Consider declaring the function "do_impure_stuff_d" as `#[storage(write)]`
+
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn test_function_d() -> bool
+#nextln: $()Function "test_function_d" is pure and cannot access storage.
+#check: $()do_impure_stuff_d()
+#nextln: $()Function "do_impure_stuff_d" writes to the storage.
+#check: $()Consider declaring the function "test_function_d" as `#[storage(write)]`
+
+#check: $()16 errors.
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/src/main.sw
deleted file mode 100644
index 64c94f04eef..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/src/main.sw
+++ /dev/null
@@ -1,18 +0,0 @@
-script;
-
-// str in constants is not allowed
-const A: str = "abc";
-
-// str in configurable is not allowed
-configurable {
-    B: str = "abc",
-}
-
-// str in main args is not allowed
-// main returning str is not allowed
-fn main(s: str) -> str {
-    let a: str = "abc";
-    let _b: str[3] = __to_str_array(a);
-    
-    s
-}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/test.toml
deleted file mode 100644
index 41edd57f4bd..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/test.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-category = "fail"
-
-# check: $()Expected string literal
-# check: $()`str` or a type containing `str` on `main()` arguments is not allowed
-# check: $()Returning `str` or a type containing `str` from `main()` is not allowed
-# check: $()`str` or a type containing `str` on `const` is not allowed
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/src/main.sw
index 7ab423a42ba..c501dc4a681 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/src/main.sw
@@ -84,9 +84,6 @@ fn main() {
         _ => false,
     };
 
-    // TODO: Unfortunately, at the moment we do not provide a help message here that
-    // the error is coming from the enum declaration and not variable annotation.
-    // This will wait until we introduce a separate type inference step.
     let s: GenericStruct<_, bool> = GenericStruct::<u8, _> { a: 123u64, b: true };
     let _ = s.a == 123u8; // No error here.
     let _ = s.b == true; // No error here.
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/test.toml
index b66666a14eb..5e7ddbbb42e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/struct_instantiation_type_mismatch/test.toml
@@ -132,7 +132,7 @@ category = "fail"
 #nextln: $()Mismatched types.
 #nextln: $()expected: u8
 #nextln: $()found:    u64.
-#nextln: $()Variable declaration's type annotation does not match up with the assigned expression's type.
+#nextln: $()Struct field's type must match the type specified in its declaration.
 #nextln: $()let _ = s.a == 123u8; // No error here.
 #nextln: $()let _ = s.b == true; // No error here.
 
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods1/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods1/test.toml
index d97570c1c9c..e10407ebe8e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods1/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods1/test.toml
@@ -1,3 +1,3 @@
 category = "fail"
 
-# check: $()ABI cannot define a method with the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
+# check: $()ABI cannot define a method of the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods2/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods2/test.toml
index 846a2d64e8f..748bbbd6c3e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods2/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods2/test.toml
@@ -1,3 +1,3 @@
 category = "fail"
 
-# check: $()ABI cannot define a method with the same name as its super-ABI "MySuperSuperAbi"
\ No newline at end of file
+# check: $()ABI cannot define a method of the same name as its super-ABI "MySuperSuperAbi"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods6/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods6/test.toml
index 2e420db800d..5841221adfd 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods6/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods6/test.toml
@@ -2,4 +2,4 @@ category = "fail"
 
 # check: $()error
 # check: $()fn method() {}
-# check: $()ABI cannot define a method with the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
+# check: $()ABI cannot define a method of the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods7/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods7/test.toml
index c2230c44ed5..bdd72aa2de2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods7/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods7/test.toml
@@ -1,4 +1,4 @@
 category = "fail"
 
 # check: $()error
-# check: $()ABI cannot define a method with the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
+# check: $()ABI cannot define a method of the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods8/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods8/test.toml
index 2e420db800d..5841221adfd 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods8/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods8/test.toml
@@ -2,4 +2,4 @@ category = "fail"
 
 # check: $()error
 # check: $()fn method() {}
-# check: $()ABI cannot define a method with the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
+# check: $()ABI cannot define a method of the same name as its super-ABI "MySuperAbi"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods9/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods9/test.toml
index 846a2d64e8f..748bbbd6c3e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods9/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/superabi_duplicate_methods9/test.toml
@@ -1,3 +1,3 @@
 category = "fail"
 
-# check: $()ABI cannot define a method with the same name as its super-ABI "MySuperSuperAbi"
\ No newline at end of file
+# check: $()ABI cannot define a method of the same name as its super-ABI "MySuperSuperAbi"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_impl/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_impl/src/main.sw
index 6b7dfc50141..601c07bc4d7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_impl/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_impl/src/main.sw
@@ -1,14 +1,9 @@
-script;
+library;
 
 trait ConstantId {
     const ID: u32;
 }
 
-struct Struct {}
+struct Struct { }
 
-impl ConstantId for Struct {
-}
-
-fn main() -> u32 {
-  0
-}
+impl ConstantId for Struct { }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_type_ascription/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_type_ascription/src/main.sw
index 7e454f784a2..4d9719e8e0e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_type_ascription/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_missing_type_ascription/src/main.sw
@@ -1,9 +1,5 @@
-script;
+library;
 
 trait ConstantId {
     const ID;
 }
-
-fn main() -> u32 {
-  0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_multiple_same_name/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_multiple_same_name/src/main.sw
index c752354e9f5..e20c4016b48 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_multiple_same_name/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_associated_const_multiple_same_name/src/main.sw
@@ -1,10 +1,6 @@
-script;
+library;
 
 trait ConstantId {
     const ID: u32;
     const ID: u32;
 }
-
-fn main() -> u32 {
-  0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/Forc.lock
new file mode 100644
index 00000000000..67d2281e1fb
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-599A6910FBBA5980"
+
+[[package]]
+name = "std"
+source = "path+from-root-599A6910FBBA5980"
+dependencies = ["core"]
+
+[[package]]
+name = "trait_inference_multiple_options"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/Forc.toml
new file mode 100644
index 00000000000..fb872d12ccd
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "trait_inference_multiple_options"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/src/main.sw
new file mode 100644
index 00000000000..d1b3a111451
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/src/main.sw
@@ -0,0 +1,40 @@
+script;
+
+pub trait MyFrom<T> {
+    fn from(b: T) -> Self;
+}
+
+
+pub trait MyInto<T> {
+    fn into(self) -> T;
+}
+
+
+impl<T, U> MyInto<U> for T
+where
+    U: MyFrom<T>,
+{
+    fn into(self) -> U {
+        U::from(self)
+    }
+}
+
+impl MyFrom<u256> for (u64, u64, u64, u64) {
+    fn from(val: u256) -> (u64, u64, u64, u64) {
+        (42, 0, 0, 0)
+    }
+}
+
+impl MyFrom<u256> for (u64, u64, u64, u32) {
+    fn from(val: u256) -> (u64, u64, u64, u32) {
+        (42, 0, 0, 0)
+    }
+}
+
+fn main() -> bool {
+    let (a, _b, _c, _d) = u256::min().into();
+
+    assert_eq(a, 42);
+    
+    true
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/test.toml
new file mode 100644
index 00000000000..05ebf7976f4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_inference_multiple_options/test.toml
@@ -0,0 +1,6 @@
+category = "fail"
+
+# check: $()Multiple impls satisfying MyFrom<u256> for (numeric, _, _, _)
+# check: $()Trait implemented for types:
+# nextln: $()#0 MyFrom<u256> for (u64, u64, u64, u64)
+# nextln: $()#1 MyFrom<u256> for (u64, u64, u64, u32)
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.lock
index 441af3974f3..c918557d18e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
-name = 'trait_pure_calls_impure'
-source = 'member'
+name = "core"
+source = "path+from-root-C42A95D87AAB6BDD"
+
+[[package]]
+name = "trait_pure_calls_impure"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.toml
index cf4b4d43dae..20ab2e0ecfe 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/Forc.toml
@@ -4,3 +4,6 @@ authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
 implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/src/main.sw
index b2ed9386c54..5e70bda7632 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/src/main.sw
@@ -8,3 +8,25 @@ trait A {
         self.f()
     }
 }
+
+struct S {}
+
+impl A for S {
+    #[storage(read)]
+    fn f(self) -> bool {
+        let _ = __state_load_word(b256::zero());
+        true
+    }
+}
+
+abi Abi {
+    #[storage(read)]
+    fn test() -> bool;
+}
+
+impl Abi for Contract {
+    #[storage(read)]
+    fn test() -> bool {
+        S {}.g()
+    }
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/test.toml
index 4df8d76a952..5f48cb0399a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/trait_pure_calls_impure/test.toml
@@ -1,4 +1,9 @@
 category = "fail"
 
-# check: self.f()
-# nextln: $()Storage attribute access mismatch. Try giving the surrounding function more access by adding "#[storage(read)]" to the function declaration.
+#check: $()error
+#sameln: $()Pure function cannot access storage
+#check: $()fn g(self) -> bool
+#nextln: $()Function "g" is pure and cannot access storage.
+#check: $()self.f()
+#nextln: $()Function "f" reads from the storage.
+#check: $()Consider declaring the function "g" as `#[storage(read)]`
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/Forc.lock
new file mode 100644
index 00000000000..0414a55e1f7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-4E3E49D8CAB8B648"
+
+[[package]]
+name = "std"
+source = "path+from-root-4E3E49D8CAB8B648"
+dependencies = ["core"]
+
+[[package]]
+name = "type_check_analyze_errors"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/Forc.toml
similarity index 83%
rename from test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/Forc.toml
index 702203ab0a5..6eb9a08e419 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/storage_conflict/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/Forc.toml
@@ -1,9 +1,9 @@
 [project]
-name = "storage_conflict"
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
-license = "Apache-2.0"
 implicit-std = false
+license = "Apache-2.0"
+name = "type_check_analyze_errors"
 
 [dependencies]
 std = { path = "../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/snapshot.toml
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/snapshot.toml
@@ -0,0 +1 @@
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw
new file mode 100644
index 00000000000..6fae9c87c7e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw
@@ -0,0 +1,22 @@
+script;
+
+fn main() {
+    // 0x100 does not fit into a u8
+    let _a = 0x100;
+    Vec::<u8>::new().push(_a);
+
+    // 0x10000 does not fit into a u16
+    let _a = 0x10000;
+    Vec::<u16>::new().push(_a);
+
+    // 0x100000000 does not fit into a u32
+    let _a = 0x100000000;
+    Vec::<u32>::new().push(_a);
+
+    
+}
+
+fn insufficient_type_check(arg: u64) -> [u32;2] {
+    let res = [1u32, arg];
+    res
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/stdout.snap
new file mode 100644
index 00000000000..cc63d82067b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/stdout.snap
@@ -0,0 +1,63 @@
+---
+source: test/tests/tests.rs
+---
+> forc build --path test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors
+exit status: 1
+output:
+    Building test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors
+   Compiling library core (sway-lib-core)
+   Compiling library std (sway-lib-std)
+   Compiling script type_check_analyze_errors (test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors)
+error
+ --> test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw:5:14
+  |
+3 | fn main() {
+4 |     // 0x100 does not fit into a u8
+5 |     let _a = 0x100;
+  |              ^^^^^ Literal would overflow because its value does not fit into "u8"
+6 |     Vec::<u8>::new().push(_a);
+7 | 
+  |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw:9:14
+   |
+ 7 | 
+ 8 |     // 0x10000 does not fit into a u16
+ 9 |     let _a = 0x10000;
+   |              ^^^^^^^ Literal would overflow because its value does not fit into "u16"
+10 |     Vec::<u16>::new().push(_a);
+11 | 
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw:13:14
+   |
+11 | 
+12 |     // 0x100000000 does not fit into a u32
+13 |     let _a = 0x100000000;
+   |              ^^^^^^^^^^^ Literal would overflow because its value does not fit into "u32"
+14 |     Vec::<u32>::new().push(_a);
+15 | 
+   |
+____
+
+error
+  --> test/src/e2e_vm_tests/test_programs/should_fail/type_check_analyze_errors/src/main.sw:20:22
+   |
+18 | 
+19 | fn insufficient_type_check(arg: u64) -> [u32;2] {
+20 |     let res = [1u32, arg];
+   |                      ^^^ Mismatched types.
+expected: u32
+found:    u64.
+
+21 |     res
+22 | }
+   |
+____
+
+  Aborting due to 4 errors.
+error: Failed to compile type_check_analyze_errors
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/Forc.lock
similarity index 52%
rename from test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/Forc.lock
index d0af35185a5..fce6a8f0290 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/pure_calls_impure/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/Forc.lock
@@ -1,3 +1,3 @@
 [[package]]
-name = 'pure_calls_impure'
+name = 'type_propagation'
 source = 'member'
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/Forc.toml
similarity index 80%
rename from test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/Forc.toml
index 9b7fb8fa6c9..e4314b87f75 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/Forc.toml
@@ -1,8 +1,6 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
-license = "Apache-2.0"
-name = "midenvm_trivial"
 entry = "main.sw"
+license = "Apache-2.0"
+name = "type_propagation"
 implicit-std = false
-
-
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/src/main.sw
new file mode 100644
index 00000000000..02cfe552671
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/src/main.sw
@@ -0,0 +1,27 @@
+library;
+
+struct Vec<T> {}
+
+impl<T> Vec<T> {
+  fn new() -> Self { return Self {}}
+  fn push(self, elem: T) {}
+}
+
+trait Wrap {
+ fn wrap(self) -> Vec<Self>;
+}
+
+impl<T> Wrap for Vec<T> {
+  fn wrap(self) -> Vec<Self> {
+   let mut v = Vec::new();
+   v.push(self);
+   v
+  }
+}
+
+fn main() {
+ let mut a: Vec<_> = Vec::new();
+ let b: Vec<Vec<_>> = a.wrap();
+ let c: Vec<Vec<Vec<u8>>> = b.wrap();
+ a.push("str");
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/test.toml
new file mode 100644
index 00000000000..5e4e3480d0b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/type_propagation/test.toml
@@ -0,0 +1,5 @@
+category = "fail"
+
+# check: $()a.push("str");
+# check: $()a.push("str");
+# nextln: $()This parameter was declared as type u8, but argument of type str was provided
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/Forc.lock
deleted file mode 100644
index 1b37fb7e1f1..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/Forc.lock
+++ /dev/null
@@ -1,3 +0,0 @@
-[[package]]
-name = 'unrecognized_opcode'
-source = 'member'
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/src/main.sw
deleted file mode 100644
index 1fc663e5516..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/src/main.sw
+++ /dev/null
@@ -1,8 +0,0 @@
-script;
-
-fn main() {
-    let _x = asm (r1, r2: 0, r3: 0) {
-        modd r1 r2 r3;
-        r1: u64
-    };
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/test.toml
deleted file mode 100644
index 5354716275a..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_fail/unrecognized_opcode/test.toml
+++ /dev/null
@@ -1,4 +0,0 @@
-category = "fail"
-
- # check: $()modd r1 r2 r3;
- # check: $()Unrecognized op code.
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl_u16/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl_u16/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl_u16/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/blanket_impl_u16/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/break_in_strange_positions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/break_in_strange_positions/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/break_in_strange_positions/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/break_in_strange_positions/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/continue_in_strange_positions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/continue_in_strange_positions/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/continue_in_strange_positions/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/continue_in_strange_positions/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/forc/dependency_package_field/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/forc/dependency_package_field/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/forc/dependency_package_field/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/forc/dependency_package_field/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/Forc.lock
new file mode 100644
index 00000000000..1693df3a853
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-0C133FB33C94FAC1"
+
+[[package]]
+name = "impl_self_dependency_order_conflict"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-0C133FB33C94FAC1"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/Forc.toml
similarity index 76%
rename from test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/Forc.toml
index 3f28e085114..d50f5de5701 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/generic_trait_tuple_without_type_ascription/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/Forc.toml
@@ -1,8 +1,8 @@
 [project]
-authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
+authors = ["Fuel Labs <contact@fuel.sh>"]
 license = "Apache-2.0"
-name = "generic_trait_tuple_without_type_ascription"
+name = "impl_self_dependency_order_conflict"
 
 [dependencies]
 std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/src/foo.sw b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/src/foo.sw
new file mode 100644
index 00000000000..11422a3c6a0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/src/foo.sw
@@ -0,0 +1,5 @@
+library;
+
+pub fn foo() -> u32 {
+    1
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/src/main.sw
new file mode 100644
index 00000000000..76a5d4c4a1e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/src/main.sw
@@ -0,0 +1,27 @@
+library;
+
+mod foo;
+use foo::*;
+
+struct S {}
+
+impl S {   //dependency of this impl is overwritten by the next impl
+    fn a() -> u32 { foo() }
+    fn b() {}
+}
+
+impl S {   //this will overwrite the dependency for the previous impl
+    fn ab() {}
+}
+
+fn foo() -> u32 {
+  2
+}
+
+fn main() {}
+
+#[test]
+fn test() {
+  assert_eq(2, S::a());
+}
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/test.toml
new file mode 100644
index 00000000000..f5f5a974e08
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/impl_self_dependency_order_conflict/test.toml
@@ -0,0 +1,2 @@
+category = "unit_tests_pass"
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/Forc.lock
new file mode 100644
index 00000000000..5b18add0faf
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "abi_cast_nested_method"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-0D81C4DB888BC505"
+
+[[package]]
+name = "std"
+source = "path+from-root-0D81C4DB888BC505"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/Forc.toml
new file mode 100644
index 00000000000..41edb934da4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "abi_cast_nested_method"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/src/main.sw
new file mode 100644
index 00000000000..6f08f7204de
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/src/main.sw
@@ -0,0 +1,21 @@
+script;
+
+abi AMM {
+    fn pool() -> Option<ContractId>;
+}
+abi Exchange {
+    fn swap_exact_output();
+}
+
+fn main() {
+    let amm_contract = abi(AMM, 0x0000000000000000000000000000000000000000000000000000000000000000);
+
+    let exchange_contract_id = amm_contract.pool();
+
+    // let a =  exchange_contract_id.unwrap().into();
+    // let exchange_contract = abi(Exchange, a);
+
+    let exchange_contract = abi(Exchange, exchange_contract_id.unwrap().into());
+    
+    exchange_contract.swap_exact_output();
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/test.toml
new file mode 100644
index 00000000000..2c5bf1ae09a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/abi_cast_nested_method/test.toml
@@ -0,0 +1,2 @@
+category = "compile"
+expected_warnings = 0
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/abort_control_flow_good/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/abort_control_flow_good/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/abort_control_flow_good/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/abort_control_flow_good/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/aliased_imports/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/aliased_imports/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/aliased_imports/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/aliased_imports/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/args_on_stack/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/args_on_stack/src/main.sw
index d755563c275..877225f59a6 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/args_on_stack/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/args_on_stack/src/main.sw
@@ -15,8 +15,143 @@ fn foo(a: u64, b: A, c: u64, d: u256, e: b256, f: String, g: [u64; 2], h: b256,
    a + b.j + c + g[0] + j + f.as_bytes().len() + i.as_bytes().len()
 }
 
+#[inline(never)]
+fn bar(a: u64, b: A, c: u64, d: u256, e: b256, f: String, g: [u64; 2], h: b256, i: String, j: u64) -> u64 {
+   let a_arr : [u64; 4096] = [
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+   ];
+   foo(a_arr[a], b, c, d, e, f, g, h, i, j)
+}
+
 fn main() -> u64 {
-    foo(
+    bar(
           11,
           A { i: 0, j: 2 },
           1,
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/array_basics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/array_basics/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/array_basics/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/array_basics/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/array_generics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/array_generics/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/array_generics/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/array_generics/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/Forc.lock
new file mode 100644
index 00000000000..c68cca1e72d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = "asm_empty_block"
+source = "member"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/Forc.toml
new file mode 100644
index 00000000000..33c899de8f6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "asm_empty_block"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/src/main.sw
new file mode 100644
index 00000000000..dc0662d5895
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/src/main.sw
@@ -0,0 +1,18 @@
+library;
+
+pub fn test() {
+    let _ = asm() {
+    };
+
+    let _ = asm() { };
+
+    let _ = asm(r1: 0) { };
+
+    let _ = asm() { zero };
+
+    let _ = asm() { zero: u32 };
+
+    let _ = asm(r1: 0, res) {
+        addi res r1 i0;
+    };
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/test.toml
new file mode 100644
index 00000000000..458c8abb30c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_empty_block/test.toml
@@ -0,0 +1,17 @@
+category = "compile"
+expected_warnings = 3
+
+#check: $()warning
+#sameln: $()ASM block is empty
+#check: $()let _ = asm() {
+#check: $()This ASM block is empty.
+
+#check: $()warning
+#sameln: $()ASM block is empty
+#check: $()let _ = asm() { };
+#nextln: $()This ASM block is empty.
+
+#check: $()warning
+#sameln: $()ASM block is empty
+#check: $()let _ = asm(r1: 0) { };
+#nextln: $()This ASM block is empty.
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_expr_basic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_expr_basic/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_expr_basic/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_expr_basic/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/Forc.lock
new file mode 100644
index 00000000000..895eeb65a4f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "asm_uninitialized_register_shadows_item"
+source = "member"
+dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-B978682C941EBFB4"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/Forc.toml
similarity index 79%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/Forc.toml
index 2492c0bf71b..e99e6f10031 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/Forc.toml
@@ -2,7 +2,7 @@
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "associated_const_impl_self_order"
+name = "asm_uninitialized_register_shadows_item"
 implicit-std = false
 
 [dependencies]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/src/main.sw
new file mode 100644
index 00000000000..e4200fb6d8e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/src/main.sw
@@ -0,0 +1,102 @@
+contract;
+
+configurable {
+    CONFIG: u64 = 0,
+}
+
+pub fn test() {
+    let x = 0;
+    let y = 0;
+
+    // Shadowing a variable.
+
+    let _ = asm(x) { // Not used.
+        zero
+    };
+
+    let _ = asm(x) { // Used.
+        movi x i0;
+    };
+
+    let _ = asm(x: 0) {
+        zero
+    };
+
+    let _ = asm(x: x) {
+        zero
+    };
+
+    let _ = asm(x: y) {
+        zero
+    };
+
+    // Shadowing a configurable.
+
+    let _ = asm(CONFIG) { // Not used.
+        zero
+    };
+
+    let _ = asm(CONFIG) { // Used.
+        movi CONFIG i0;
+    };
+
+    let _ = asm(CONFIG: 0) {
+        zero
+    };
+
+    let _ = asm(CONFIG: CONFIG) {
+        zero
+    };
+
+    let _ = asm(CONFIG: y) {
+        zero
+    };
+
+    // Shadowing a non-local constant.
+
+    let _ = asm(G_CONST) { // Not used.
+        zero
+    };
+
+    let _ = asm(G_CONST) { // Used.
+        movi G_CONST i0;
+    };
+
+    let _ = asm(G_CONST: 0) {
+        zero
+    };
+
+    let _ = asm(G_CONST: G_CONST) {
+        zero
+    };
+
+    let _ = asm(G_CONST: y) {
+        zero
+    };
+
+    const L_CONST: u64 = 0;
+
+    // Shadowing a local constant.
+
+    let _ = asm(L_CONST) { // Not used.
+        zero
+    };
+
+    let _ = asm(L_CONST) { // Used.
+        movi L_CONST i0;
+    };
+
+    let _ = asm(L_CONST: 0) {
+        zero
+    };
+
+    let _ = asm(L_CONST: L_CONST) {
+        zero
+    };
+
+    let _ = asm(L_CONST: y) {
+        zero
+    };
+}
+
+const G_CONST: u64 = 0;
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/test.toml
new file mode 100644
index 00000000000..a26b3fe2b10
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_uninitialized_register_shadows_item/test.toml
@@ -0,0 +1,98 @@
+category = "compile"
+expected_warnings = 8
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a variable
+#check: $()let x = 0;
+#nextln: $()Variable "x" is declared here.
+#check: $()let _ = asm(x) { // Not used.
+#nextln: $()Uninitialized register "x" is shadowing a variable of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the variable?
+#nextln: $()In that case, you must do it explicitly: `x: x`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed variable, consider renaming the register "x".
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a variable
+#check: $()let x = 0;
+#nextln: $()Variable "x" is declared here.
+#check: $()let _ = asm(x) { // Used.
+#nextln: $()Uninitialized register "x" is shadowing a variable of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the variable?
+#nextln: $()In that case, you must do it explicitly: `x: x`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed variable, consider renaming the register "x".
+
+#not: let _ = asm(x: 0)
+#not: let _ = asm(x: x)
+#not: let _ = asm(x: y)
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a configurable
+#check: $()CONFIG: u64 = 0,
+#nextln: $()Configurable "CONFIG" is declared here.
+#check: $()let _ = asm(CONFIG) { // Not used.
+#nextln: $()Uninitialized register "CONFIG" is shadowing a configurable of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the configurable?
+#nextln: $()In that case, you must do it explicitly: `CONFIG: CONFIG`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed configurable, consider renaming the register "CONFIG".
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a configurable
+#check: $()CONFIG: u64 = 0,
+#nextln: $()Configurable "CONFIG" is declared here.
+#check: $()let _ = asm(CONFIG) { // Used.
+#nextln: $()Uninitialized register "CONFIG" is shadowing a configurable of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the configurable?
+#nextln: $()In that case, you must do it explicitly: `CONFIG: CONFIG`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed configurable, consider renaming the register "CONFIG".
+
+#not: let _ = asm(CONFIG: 0)
+#not: let _ = asm(CONFIG: CONFIG)
+#not: let _ = asm(CONFIG: y)
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a constant
+#check: $()let _ = asm(G_CONST) { // Not used.
+#nextln: $()Uninitialized register "G_CONST" is shadowing a constant of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the constant?
+#nextln: $()In that case, you must do it explicitly: `G_CONST: G_CONST`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed constant, consider renaming the register "G_CONST".
+#check: $()const G_CONST: u64 = 0;
+#nextln: $()Constant "G_CONST" is declared here.
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a constant
+#check: $()let _ = asm(G_CONST) { // Used.
+#nextln: $()Uninitialized register "G_CONST" is shadowing a constant of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the constant?
+#nextln: $()In that case, you must do it explicitly: `G_CONST: G_CONST`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed constant, consider renaming the register "G_CONST".
+#check: $()const G_CONST: u64 = 0;
+#nextln: $()Constant "G_CONST" is declared here.
+
+#not: let _ = asm(G_CONST: 0)
+#not: let _ = asm(G_CONST: G_CONST)
+#not: let _ = asm(G_CONST: y)
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a constant
+#check: $()const L_CONST: u64 = 0;
+#nextln: $()Constant "L_CONST" is declared here.
+#check: $()let _ = asm(L_CONST) { // Not used.
+#nextln: $()Uninitialized register "L_CONST" is shadowing a constant of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the constant?
+#nextln: $()In that case, you must do it explicitly: `L_CONST: L_CONST`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed constant, consider renaming the register "L_CONST".
+
+#check: $()warning
+#sameln: $()Uninitialized ASM register is shadowing a constant
+#check: $()const L_CONST: u64 = 0;
+#nextln: $()Constant "L_CONST" is declared here.
+#check: $()let _ = asm(L_CONST) { // Used.
+#nextln: $()Uninitialized register "L_CONST" is shadowing a constant of the same name.
+#nextln: $()Are you trying to initialize the register to the value of the constant?
+#nextln: $()In that case, you must do it explicitly: `L_CONST: L_CONST`.
+#nextln: $()Otherwise, to avoid the confusion with the shadowed constant, consider renaming the register "L_CONST".
+
+#not: let _ = asm(L_CONST: 0)
+#not: let _ = asm(L_CONST: L_CONST)
+#not: let _ = asm(L_CONST: y)
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.lock
index 99cddc51e15..ff9e2c5ddbc 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.lock
@@ -1,8 +1,3 @@
 [[package]]
 name = "asm_without_return"
 source = "member"
-dependencies = ["core"]
-
-[[package]]
-name = "core"
-source = "path+from-root-8F74D3135E693ACB"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.toml
index a61e721b2cf..75dca95945d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/Forc.toml
@@ -4,6 +4,3 @@ entry = "main.sw"
 license = "Apache-2.0"
 name = "asm_without_return"
 implicit-std = false
-
-[dependencies]
-core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/src/main.sw
index 5293a2ac763..7823d9009f5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/src/main.sw
@@ -1,6 +1,6 @@
-script;
+library;
 
-fn main() {
+pub fn test() {
     asm() {
     };
 
@@ -8,4 +8,27 @@ fn main() {
         add r3 r1 r2;
         add r4 r2 r2;
     };
+
+    // These cases prove that https://github.com/FuelLabs/sway/issues/6354 is fixed.
+    poke(asm() { });
+
+    let arg_u8 = 11u8;
+
+    poke(asm(a: arg_u8, b: arg_u8, res) {
+        add res a b;
+    });
+
+    let x = asm(a: arg_u8, b: arg_u8, res) {
+        add res a b;
+    };
+    
+    poke(x);
+
+    // Return the unit result of ASM block as function result.
+    asm(r1: 5, r2: 5, r3) {
+        add r3 r1 r2;
+    }
 }
+
+#[inline(never)]
+fn poke<T>(_x: T) { }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/test.toml
index 8fb3859ce4c..f067d2a5f9e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/test.toml
@@ -1,4 +1,2 @@
-category = "run"
-expected_result = { action = "return", value = 0 }
-expected_result_new_encoding = { action = "return_data", value = "" }
-validate_abi = true
+category = "compile"
+expected_warnings = 2
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/Forc.lock
new file mode 100644
index 00000000000..3b576dee330
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "asm_wqxx_instructions"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-DEA77F133437397D"
+
+[[package]]
+name = "std"
+source = "path+from-root-DEA77F133437397D"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/Forc.toml
new file mode 100644
index 00000000000..c44f1f66715
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "asm_wqxx_instructions"
+
+[dependencies]
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/src/main.sw
new file mode 100644
index 00000000000..3203aa3b494
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/src/main.sw
@@ -0,0 +1,137 @@
+library;
+
+const ZERO: b256 = b256::zero();
+const ONE: b256 = 0x0000000000000000000000000000000000000000000000000000000000000001;
+const TWO: b256 = 0x0000000000000000000000000000000000000000000000000000000000000002;
+const THREE: b256 = 0x0000000000000000000000000000000000000000000000000000000000000003;
+const FOUR: b256 = 0x0000000000000000000000000000000000000000000000000000000000000004;
+const FIVE: b256 = 0x0000000000000000000000000000000000000000000000000000000000000005;
+const NINE: b256 = 0x0000000000000000000000000000000000000000000000000000000000000009;
+const TEN: b256 = 0x000000000000000000000000000000000000000000000000000000000000000A;
+
+#[test]
+fn wqml() {
+    let mut res = ZERO;
+
+    let a: b256 = TWO;
+    let b: b256 = TWO;
+
+    asm(res: res, a: a, b: b) {
+        wqml res a b i48;
+    }
+
+    assert_eq(res, FOUR);
+
+    let a: u64 = 5;
+    let b: u64 = 2;
+
+    asm(res: res, a: a, b: b) {
+        wqml res a b i0;
+    }
+
+    assert_eq(res, TEN);
+
+    asm(res: res, a: ZERO, b: ZERO) {
+        wqml res a b i48;
+    }
+
+    assert_eq(res, ZERO);
+
+    let a: b256 = THREE;
+    let b: u64 = 3;
+
+    asm(res: res, a: a, b: b) {
+        wqml res a b i16;
+    }
+
+    assert_eq(res, NINE);
+}
+
+#[test]
+fn all_in_one() {
+    // WQCM
+    let a: b256 = TWO;
+    let b: b256 = TWO;
+
+    let bool_res = asm(b_res, a: a, b: b) {
+        wqcm b_res a b i32; // a == b
+        b_res: bool
+    };
+
+    assert_eq(bool_res, true);
+
+    // WQOP
+    let mut res = TEN;
+
+    let a: b256 = TEN;
+    let b: b256 = NINE;
+
+    asm(res: res, a: a, b: b) {
+        wqop res a b i33; // a - b
+    };
+
+    assert_eq(res, ONE);
+
+    // WQML
+    let mut res = ZERO;
+
+    let a: b256 = TWO;
+    let b: b256 = TWO;
+
+    asm(res: res, a: a, b: b) {
+        wqml res a b i48; // 2 * 2
+    }
+
+    assert_eq(res, FOUR);
+
+    // WQDV
+    let mut res = ZERO;
+
+    let a: b256 = TEN;
+    let b: b256 = FIVE;
+
+    asm(res: res, a: a, b: b) {
+        wqdv res a b i32; // 10 / 5
+    }
+
+    assert_eq(res, TWO);
+
+    // WQMD
+    let mut res = ZERO;
+
+    let a: b256 = TEN;
+    let b: b256 = TWO;
+    let c: b256 = FIVE;
+
+    asm(res: res, a: a, b: b, c: c) {
+        wqmd res a b c; // (10 * 2) / 5
+    }
+
+    assert_eq(res, FOUR);
+
+    // WQAM
+    let mut res = ZERO;
+
+    let a: b256 = TEN;
+    let b: b256 = TWO;
+    let c: b256 = FIVE;
+
+    asm(res: res, a: a, b: b, c: c) {
+        wqam res a b c; // (10 + 2) % 5
+    }
+
+    assert_eq(res, TWO);
+
+    // WQMM
+    let mut res = ZERO;
+
+    let a: b256 = TEN;
+    let b: b256 = TWO;
+    let c: b256 = THREE;
+
+    asm(res: res, a: a, b: b, c: c) {
+        wqmm res a b c; // (10 * 2) % 3
+    }
+
+    assert_eq(res, TWO);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/test.toml
new file mode 100644
index 00000000000..f1958c1b086
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_wqxx_instructions/test.toml
@@ -0,0 +1 @@
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.lock
index dd9b0922b9e..686cc4d810c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.lock
@@ -1,8 +1,13 @@
 [[package]]
 name = "associated_const_abi"
 source = "member"
-dependencies = ["core"]
+dependencies = ["std"]
 
 [[package]]
 name = "core"
 source = "path+from-root-A4B13C912574D35A"
+
+[[package]]
+name = "std"
+source = "path+from-root-A4B13C912574D35A"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.toml
index 9f03e7e8ee4..9064f17054d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/Forc.toml
@@ -6,4 +6,4 @@ name = "associated_const_abi"
 implicit-std = false
 
 [dependencies]
-core = { path = "../../../../../../../sway-lib-core" }
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/src/main.sw
index a4259799284..4486078f32b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/src/main.sw
@@ -1,18 +1,118 @@
-script;
+contract;
 
 abi A {
-    const ID: u32;
-    fn foo() -> u32;
+    const A_WITH_DEFAULT: u32 = 3;
+    // TODO: Uncomment this case when https://github.com/FuelLabs/sway/issues/6348 is fixed.
+    // const A_NO_DEFAULT: u32;
+    const COMMON_1: u32 = 5;
+    // TODO: Uncomment this version (without default) when https://github.com/FuelLabs/sway/issues/6348 is fixed.
+    // const COMMON_2: u32;
+    const COMMON_2: u32 = 111; // TODO: Remove this one in favor of the one without default.
+
+    fn a_with_default() -> u32;
+    // fn a_no_default() -> u32;
+
+    fn common_1() -> u32;
+    fn common_2() -> u32;
+} {
+    // TODO: Uncomment this case once `expression_variant::find_const_decl_from_impl` is implemented.
+    // fn a_implemented_with_default() -> u32 {
+    //     Self::A_WITH_DEFAULT
+    // }
+
+    // fn a_implemented_no_default() -> u32 {
+    //     Self::A_NO_DEFAULT
+    // }
+
+    // fn a_implemented_common_1() -> u32 {
+    //     Self::COMMON_1
+    // }
+
+    // fn a_implemented_common_2() -> u32 {
+    //     Self::COMMON_2
+    // }
+}
+    
+abi B {
+    // TODO: Uncomment this version (without default) when https://github.com/FuelLabs/sway/issues/6348 is fixed.
+    // const COMMON_1: u32;
+    const COMMON_1: u32 = 111; // TODO: Remove this one in favor of the one without default.
+    const COMMON_2: u32 = 7;
+
+    fn common_1() -> u32;
+    fn common_2() -> u32;
+} {
+    // TODO: Uncomment this case once `expression_variant::find_const_decl_from_impl` is implemented.
+    // fn b_implemented_common_1() -> u32 {
+    //     Self::COMMON_1
+    // }
+
+    // fn b_implemented_common_2() -> u32 {
+    //     Self::COMMON_2
+    // }
 }
 
 impl A for Contract {
-  const ID: u32 = 1;
+    const A_WITH_DEFAULT: u32 = 13;
+    // const A_NO_DEFAULT: u32 = 133;
+    const COMMON_1: u32 = 15;
+    const COMMON_2: u32 = 155;
+
+    fn a_with_default() -> u32 {
+        Self::A_WITH_DEFAULT
+    }
+
+    // fn a_no_default() -> u32 {
+    //     Self::A_NO_DEFAULT
+    // }
+
+    fn common_1() -> u32 {
+        Self::COMMON_1
+    }
 
-  fn foo() -> u32 {
-    Self::ID
-  }
+    fn common_2() -> u32 {
+        Self::COMMON_2
+    }
 }
 
-fn main() -> u32 {
-  0
+impl B for Contract {
+    const COMMON_1: u32 = 177;
+    const COMMON_2: u32 = 17;
+
+    fn common_1() -> u32 {
+        Self::COMMON_1
+    }
+
+    fn common_2() -> u32 {
+        Self::COMMON_2
+    }
+}
+
+#[test]
+fn test() {
+    let a = abi(A, CONTRACT_ID);
+    // TODO: Enable these asserts once these bugs are fixed:
+    //       https://github.com/FuelLabs/sway/issues/6310
+    //       https://github.com/FuelLabs/sway/issues/6306
+    //       https://github.com/FuelLabs/sway/issues/6348
+
+    // assert_eq(13, a.a_with_default());
+    // assert_eq(13, a.a_implemented_with_default());
+
+    // assert_eq(133, a.a_no_default());
+    // assert_eq(133, a.a_implemented_no_default());
+
+    // assert_eq(15, a.common_1());
+    // assert_eq(15, a.a_implemented_common_1());
+
+    // assert_eq(155, a.common_2());
+    // assert_eq(155, a.a_implemented_common_2());
+
+    let b = abi(B, CONTRACT_ID);
+
+    // assert_eq(177, b.common_1());
+    // assert_eq(177, b.b_implemented_common_1());
+
+    // assert_eq(17, b.common_2());
+    // assert_eq(17, b.b_implemented_common_2());
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/test.toml
index 09a31735c3e..f1958c1b086 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi/test.toml
@@ -1,4 +1 @@
-category = "run"
-expected_result = { action = "return", value = 0 }
-expected_result_new_encoding = { action = "return_data", value = "00000000" }
-expected_warnings = 1
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/src/main.sw
deleted file mode 100644
index 5b9afd27fbc..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/src/main.sw
+++ /dev/null
@@ -1,18 +0,0 @@
-script;
-
-abi A {
-    const ID: u32 = 1;
-    fn foo() -> u32;
-}
-
-impl A for Contract {
-  const ID: u32 = 2;
-
-  fn foo() -> u32 {
-    Self::ID
-  }
-}
-
-fn main() -> u32 {
-  0
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.lock
index 18e62b0e0be..fe7cbd9fc55 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.lock
@@ -1,8 +1,13 @@
 [[package]]
 name = "associated_const_abi_multiple"
 source = "member"
-dependencies = ["core"]
+dependencies = ["std"]
 
 [[package]]
 name = "core"
 source = "path+from-root-3E220BDD714ECD9F"
+
+[[package]]
+name = "std"
+source = "path+from-root-3E220BDD714ECD9F"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.toml
index c4026d220ee..66d92d05cb6 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/Forc.toml
@@ -6,4 +6,4 @@ name = "associated_const_abi_multiple"
 implicit-std = false
 
 [dependencies]
-core = { path = "../../../../../../../sway-lib-core" }
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/src/main.sw
index 71a469b7f7b..fa5faf6f660 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/src/main.sw
@@ -1,4 +1,4 @@
-script;
+contract;
 
 abi A {
     const ID: u32 = 1;
@@ -6,26 +6,32 @@ abi A {
 }
 
 impl A for Contract {
-  const ID: u32 = 2;
+    const ID: u32 = 2;
 
-  fn foo() -> u32 {
-    Self::ID
-  }
+    fn foo() -> u32 {
+        Self::ID
+    }
 }
 
 abi B {
-    const ID: u32 = 1;
+    const ID: u32 = 3;
     fn foo() -> u32;
 }
 
 impl B for Contract {
-  const ID: u32 = 2;
+    const ID: u32 = 4;
 
-  fn foo() -> u32 {
-    Self::ID
-  }
+    fn foo() -> u32 {
+        Self::ID
+    }
 }
 
-fn main() -> u32 {
-  0
+// TODO: Enable the asserts or adapt the tests once https://github.com/FuelLabs/sway/issues/6306 is implemented.
+#[test]
+fn test() {
+    let a = abi(A, CONTRACT_ID);
+    // assert_eq(2, a.foo());
+
+    let b = abi(B, CONTRACT_ID);
+    // assert_eq(4, b.foo());
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/test.toml
index 9652497bdf0..0f3f6d7e866 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_multiple/test.toml
@@ -1,4 +1 @@
-category = "run"
-expected_result = { action = "return", value = 0 }
-expected_result_new_encoding = { action = "return_data", value = "00000000" }
-expected_warnings = 2
+category = "unit_tests_pass"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.lock
index df47b7d424c..ccad7c90008 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.lock
@@ -1,8 +1,13 @@
 [[package]]
 name = "associated_const_impl_multiple"
 source = "member"
-dependencies = ["core"]
+dependencies = ["std"]
 
 [[package]]
 name = "core"
 source = "path+from-root-593E053780B28B13"
+
+[[package]]
+name = "std"
+source = "path+from-root-593E053780B28B13"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.toml
index c25574ce716..492f8ffe36c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/Forc.toml
@@ -6,4 +6,4 @@ name = "associated_const_impl_multiple"
 implicit-std = false
 
 [dependencies]
-core = { path = "../../../../../../../sway-lib-core" }
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/src/main.sw
index 69e2d6266f5..16b0c0a137f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/src/main.sw
@@ -10,6 +10,10 @@ impl Struct {
     const ID2: u32 = 2;
 }
 
-fn main() -> u32 {
-  Struct::ID
+fn main() {}
+
+#[test]
+fn test() {
+  assert_eq(1, Struct::ID);
+  assert_eq(2, Struct::ID2);
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/test.toml
index 48bc10d2ed3..f1958c1b086 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_multiple/test.toml
@@ -1,4 +1 @@
-category = "run"
-expected_result = { action = "return", value = 1 }
-expected_result_new_encoding = { action = "return_data", value = "00000001" }
-expected_warnings = 3
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/src/main.sw
index 5a53af0232c..f3ef8fc4816 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/src/main.sw
@@ -3,14 +3,27 @@ script;
 struct Struct { }
 
 impl Struct {
-    const ID: u32 = 1;
+    const ID: u32 = 3;
 
     fn foo(self) -> u32 {
         Self::ID
     }
 }
 
+struct StructOrder { }
+
+impl StructOrder {
+    fn foo(self) -> u32 {
+        Self::ID
+    }
+
+    // The const declaration comes after the const usage.
+    const ID: u32 = 5;
+}
+
 fn main() -> u32 {
   let s = Struct {};
-  s.foo()
+  let so = StructOrder {};
+
+  s.foo() + so.foo()
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/test.toml
index 67ab8164b7f..a28e8cf188a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self/test.toml
@@ -1,4 +1,4 @@
 category = "run"
-expected_result = { action = "return", value = 1 }
-expected_result_new_encoding = { action = "return_data", value = "00000001" }
+expected_result = { action = "return", value = 8 }
+expected_result_new_encoding = { action = "return_data", value = "00000008" }
 expected_warnings = 2
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/Forc.lock
deleted file mode 100644
index 7b26582f4d1..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/Forc.lock
+++ /dev/null
@@ -1,8 +0,0 @@
-[[package]]
-name = "associated_const_impl_self_order"
-source = "member"
-dependencies = ["core"]
-
-[[package]]
-name = "core"
-source = "path+from-root-F5ACA883B083BA7B"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/src/main.sw
deleted file mode 100644
index d728467d8c8..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/src/main.sw
+++ /dev/null
@@ -1,16 +0,0 @@
-script;
-
-struct Struct { }
-
-impl Struct {
-    fn foo(self) -> u32 {
-        Self::ID
-    }
-
-    const ID: u32 = 1;
-}
-
-fn main() -> u32 {
-  let s = Struct {};
-  s.foo()
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/Forc.lock
new file mode 100644
index 00000000000..597edcadfc4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "associated_const_in_decls_of_other_constants"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-8CB91B60FB2568E4"
+
+[[package]]
+name = "std"
+source = "path+from-root-8CB91B60FB2568E4"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/Forc.toml
new file mode 100644
index 00000000000..fdcce2c7603
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/Forc.toml
@@ -0,0 +1,10 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "associated_const_in_decls_of_other_constants"
+implicit-std = false
+
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/src/main.sw
new file mode 100644
index 00000000000..cb35e4f4b19
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/src/main.sw
@@ -0,0 +1,95 @@
+contract;
+
+struct S {}
+
+impl S {
+    fn bar() -> u8 {
+        11
+    }
+}
+
+impl S {
+    // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6538 is fixed.
+    // const S_BAR: u8 = Self::bar();
+    const S_A: u8 = 11;
+    const S_B: u8 = Self::S_A;
+    const S_C: u8 = 22;
+
+    fn assoc_s_b() -> u8 {
+        Self::S_B
+    }
+
+    fn assoc_s_c() -> u8 {
+        Self::S_C
+    }
+
+    fn method_s_c(self) -> u8 {
+        Self::S_C
+    }
+}
+
+storage {
+    // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6543 is fixed.
+    // s_a: u8 = S::S_A,
+}
+
+const MOD_S_A: u8 = S::S_A;
+
+fn mod_fn_s_a() -> u8 {
+    S::S_A
+}
+
+abi Abi {
+    fn test_in_contract();
+}
+
+configurable {
+    CONFIG_S_A: u8 = S::S_A,
+}
+
+impl Abi for Contract {
+    fn test_in_contract() {
+        assert_eq(11, S::S_A);
+        assert_eq(22, S::S_C);
+
+        // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6544 is fixed.
+        // assert_eq(S::S_B, S::S_A);
+        // assert_eq(S::assoc_s_b(), S::S_B);
+        assert_eq(S::assoc_s_c(), S::S_C);
+        assert_eq(S {}.method_s_c(), S::S_C);
+
+        // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6538 is fixed.
+        // assert_eq(S::bar(), S::S_BAR);
+
+        assert_eq(S::S_A, MOD_S_A);
+
+        assert_eq(S::S_A, mod_fn_s_a());
+
+        assert_eq(S::S_A, CONFIG_S_A);
+
+        // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6543 is fixed.
+        // assert_eq(S::S_A, storage.s_a.read());
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq(11, S::S_A);
+    assert_eq(22, S::S_C);
+
+    // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6544 is fixed.
+    // assert_eq(S::S_B, S::S_A);
+    // assert_eq(S::assoc_s_b(), S::S_B);
+    assert_eq(S::assoc_s_c(), S::S_C);
+    assert_eq(S {}.method_s_c(), S::S_C);
+
+    // TODO: Uncomment this once https://github.com/FuelLabs/sway/issues/6538 is fixed.
+    // assert_eq(S::bar(), S::S_BAR);
+
+    assert_eq(S::S_A, MOD_S_A);
+
+    assert_eq(S::S_A, mod_fn_s_a());
+
+    let caller = abi(Abi, CONTRACT_ID);
+    caller.test_in_contract();
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/test.toml
new file mode 100644
index 00000000000..f1958c1b086
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_in_decls_of_other_constants/test.toml
@@ -0,0 +1 @@
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.lock
index eac1df2527c..26ab8ee77b5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.lock
@@ -1,8 +1,13 @@
 [[package]]
 name = "associated_const_trait"
 source = "member"
-dependencies = ["core"]
+dependencies = ["std"]
 
 [[package]]
 name = "core"
 source = "path+from-root-48B1B6A6B3A2C079"
+
+[[package]]
+name = "std"
+source = "path+from-root-48B1B6A6B3A2C079"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.toml
index ef92e798716..ea18dd79b02 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/Forc.toml
@@ -6,4 +6,4 @@ name = "associated_const_trait"
 implicit-std = false
 
 [dependencies]
-core = { path = "../../../../../../../sway-lib-core" }
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/main.sw
index 0b0a68d9893..1e50dfe0cf4 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/main.sw
@@ -1,15 +1,106 @@
-script;
+library;
 
-trait ConstantId {
-    const ID: u32;
-}
+mod traits;
+
+use traits::*;
+
+struct Struct { }
 
-struct Struct {}
+impl Struct {
+    const ID: u32 = 3;
+
+    fn foo() -> u32 {
+        Self::ID
+    }
+}
 
 impl ConstantId for Struct {
-  const ID: u32 = 1;
+    const ID: u32 = 5;
+}
+
+impl OtherConstantId for Struct {
+    const ID: u32 = 7;
+}
+
+impl GenericConstantId<u64> for Struct {
+    const ID: u64 = 9;
+}
+
+impl GenericConstantId<bool> for Struct {
+    const ID: bool = true;
+}
+
+impl GenericConstantIdWithDefault<u64> for Struct {
+    const ID: u64 = 11;
+}
+
+impl GenericConstantIdWithDefault<bool> for Struct {
+    const ID: bool = true;
+}
+
+enum Enum { }
+
+impl Enum {
+    const ID: u32 = 3;
+
+    // TODO: Uncomment this function once https://github.com/FuelLabs/sway/issues/6344 is fixed.
+    // fn foo() -> u32 {
+    //     Self::ID
+    // }
 }
 
-fn main() -> u32 {
-  Struct::ID
+impl ConstantId for Enum {
+    const ID: u32 = 5;
 }
+
+impl OtherConstantId for Enum {
+    const ID: u32 = 7;
+}
+
+impl GenericConstantId<u64> for Enum {
+    const ID: u64 = 9;
+}
+
+impl GenericConstantId<bool> for Enum {
+    const ID: bool = true;
+}
+
+impl GenericConstantIdWithDefault<u64> for Enum {
+    const ID: u64 = 11;
+}
+
+impl GenericConstantIdWithDefault<bool> for Enum {
+    const ID: bool = true;
+}
+
+#[test]
+fn test_for_structs() {
+    // TODO: Uncomment this assert once https://github.com/FuelLabs/sway/issues/6345 is fixed.
+    // assert_eq(3, Struct::ID);
+    assert_eq(5, <Struct as ConstantId>::ID);
+    assert_eq(7, <Struct as OtherConstantId>::ID);
+
+    // TODO: Uncomment these asserts once https://github.com/FuelLabs/sway/issues/6346 is fixed.
+    // assert_eq(9, <Struct as GenericConstantId::<u64>>::ID);
+    // assert_eq(true, <Struct as GenericConstantId::<bool>>::ID);
+    // assert_eq(11, <Struct as GenericConstantIdWithDefault::<u64>>::ID);
+    // assert_eq(true, <Struct as GenericConstantIdWithDefault::<bool>>::ID);
+
+    assert_eq(3, Struct::foo());
+}
+
+
+// TODO: Uncomment this test once https://github.com/FuelLabs/sway/issues/6344 is fixed.
+// #[test]
+// fn test_for_enums() {
+//     assert_eq(3, Enum::ID);
+//     assert_eq(5, <Enum as ConstantId>::ID);
+//     assert_eq(7, <Enum as OtherConstantId>::ID);
+
+//     assert_eq(9, <Enum as GenericConstantId::<u64>>::ID);
+//     assert_eq(true, <Enum as GenericConstantId::<bool>>::ID);
+//     assert_eq(11, <Enum as GenericConstantIdWithDefault::<u64>>::ID);
+//     assert_eq(true, <Enum as GenericConstantIdWithDefault::<bool>>::ID);
+
+//     assert_eq(3, Enum::foo());
+// }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/traits.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/traits.sw
new file mode 100644
index 00000000000..7ede1154c2b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/src/traits.sw
@@ -0,0 +1,29 @@
+library;
+
+pub trait ConstantId {
+    const ID: u32;
+}
+
+pub trait OtherConstantId {
+    const ID: u32;
+}
+
+pub trait GenericConstantId<T> {
+    const ID: T;
+}
+
+pub trait Default {
+    fn default() -> Self;
+}
+
+impl Default for u64 {
+    fn default() -> Self { 0 }
+}
+
+impl Default for bool {
+    fn default() -> Self { false }
+}
+
+pub trait GenericConstantIdWithDefault<T> where T: Default {
+    const ID: T = T::default();
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/test.toml
index 0f3dfe2219a..f1958c1b086 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait/test.toml
@@ -1,4 +1 @@
-category = "run"
-expected_result = { action = "return", value = 1 }
-expected_result_new_encoding = { action = "return_data", value = "00000001" }
-expected_warnings = 1
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/Forc.lock
deleted file mode 100644
index 54b6b84c39a..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/Forc.lock
+++ /dev/null
@@ -1,8 +0,0 @@
-[[package]]
-name = "associated_const_trait_const"
-source = "member"
-dependencies = ["core"]
-
-[[package]]
-name = "core"
-source = "path+from-root-D50E1F3A87CBFC67"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/src/main.sw
deleted file mode 100644
index 5d7da8079fa..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/src/main.sw
+++ /dev/null
@@ -1,15 +0,0 @@
-script;
-
-trait T {
-    const C: bool;
-}
-
-struct S {}
-
-impl T for S {
-    const C: bool = true;
-}
-
-fn main() -> bool {
-    S::C
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.lock
index bfb6de86577..ecb419b2e6e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.lock
@@ -1,8 +1,13 @@
 [[package]]
 name = "associated_const_trait_default"
 source = "member"
-dependencies = ["core"]
+dependencies = ["std"]
 
 [[package]]
 name = "core"
 source = "path+from-root-78BED7E0142ECED8"
+
+[[package]]
+name = "std"
+source = "path+from-root-78BED7E0142ECED8"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.toml
index d6142569826..a41ff7b53f0 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/Forc.toml
@@ -7,4 +7,4 @@ implicit-std = false
 
 
 [dependencies]
-core = { path = "../../../../../../../sway-lib-core" }
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/src/main.sw
index f29057fb6d1..b61e6f93404 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/src/main.sw
@@ -1,7 +1,7 @@
 script;
 
 trait ConstantId {
-    const ID: u32 = 1;
+    const ID: u32 = 7;
 }
 
 struct Struct {}
@@ -10,6 +10,10 @@ impl ConstantId for Struct {
   const ID: u32 = 5;
 }
 
-fn main() -> u32 {
-  Struct::ID
+fn main() { }
+
+#[test]
+fn test() {
+    assert_eq(5, Struct::ID);
+    assert_eq(5, <Struct as ConstantId>::ID);
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/test.toml
index ff9771a91e5..f1958c1b086 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_default/test.toml
@@ -1,4 +1 @@
-category = "run"
-expected_result = { action = "return", value = 5 }
-expected_result_new_encoding = { action = "return_data", value = "00000005" }
-expected_warnings = 1
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bad_jumps/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bad_jumps/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bad_jumps/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bad_jumps/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bitwise_ops/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bitwise_ops/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bitwise_ops/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_bitwise_ops/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_ops/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_ops/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_ops/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/b256_ops/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/basic_func_decl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/basic_func_decl/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/basic_func_decl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/basic_func_decl/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/binary_and_hex_literals/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/binary_and_hex_literals/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/binary_and_hex_literals/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/binary_and_hex_literals/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/binop_intrinsics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/binop_intrinsics/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/binop_intrinsics/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/binop_intrinsics/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/bitwise_not/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/bitwise_not/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/bitwise_not/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/bitwise_not/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/blanket_trait/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/blanket_trait/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/blanket_trait/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/blanket_trait/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/bool_and_or/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/bool_and_or/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/bool_and_or/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/bool_and_or/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/break_and_continue/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/break_and_continue/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/break_and_continue/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/break_and_continue/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/builtin_type_method_call/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/builtin_type_method_call/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/builtin_type_method_call/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/builtin_type_method_call/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/callpath_local_shadowing/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/callpath_local_shadowing/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/callpath_local_shadowing/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/callpath_local_shadowing/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/chained_if_let/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/chained_if_let/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/chained_if_let/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/chained_if_let/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/Forc.lock
index 842942b25da..17cc4b10427 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/Forc.lock
@@ -1,13 +1,13 @@
 [[package]]
-name = 'configurable_consts'
-source = 'member'
-dependencies = ['std']
+name = "configurable_consts"
+source = "member"
+dependencies = ["std"]
 
 [[package]]
-name = 'core'
-source = 'path+from-root-7F58364AF9C32FE1'
+name = "core"
+source = "path+from-root-7F58364AF9C32FE1"
 
 [[package]]
-name = 'std'
-source = 'path+from-root-7F58364AF9C32FE1'
-dependencies = ['core']
+name = "std"
+source = "path+from-root-7F58364AF9C32FE1"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle.json
index 697f6b4dab6..096b1d487c9 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle.json
@@ -7,7 +7,7 @@
         "typeArguments": null
       },
       "name": "BOOL",
-      "offset": 3560
+      "offset": 3392
     },
     {
       "configurableType": {
@@ -16,7 +16,7 @@
         "typeArguments": null
       },
       "name": "U8",
-      "offset": 3696
+      "offset": 3528
     },
     {
       "configurableType": {
@@ -25,7 +25,7 @@
         "typeArguments": null
       },
       "name": "ANOTHER_U8",
-      "offset": 3488
+      "offset": 3320
     },
     {
       "configurableType": {
@@ -34,7 +34,7 @@
         "typeArguments": null
       },
       "name": "U16",
-      "offset": 3640
+      "offset": 3472
     },
     {
       "configurableType": {
@@ -43,7 +43,7 @@
         "typeArguments": null
       },
       "name": "U32",
-      "offset": 3680
+      "offset": 3512
     },
     {
       "configurableType": {
@@ -52,7 +52,7 @@
         "typeArguments": null
       },
       "name": "U64",
-      "offset": 3688
+      "offset": 3520
     },
     {
       "configurableType": {
@@ -61,7 +61,7 @@
         "typeArguments": null
       },
       "name": "U256",
-      "offset": 3648
+      "offset": 3480
     },
     {
       "configurableType": {
@@ -70,7 +70,7 @@
         "typeArguments": null
       },
       "name": "B256",
-      "offset": 3528
+      "offset": 3360
     },
     {
       "configurableType": {
@@ -79,7 +79,7 @@
         "typeArguments": []
       },
       "name": "CONFIGURABLE_STRUCT",
-      "offset": 3600
+      "offset": 3432
     },
     {
       "configurableType": {
@@ -88,7 +88,7 @@
         "typeArguments": []
       },
       "name": "CONFIGURABLE_ENUM_A",
-      "offset": 3568
+      "offset": 3400
     },
     {
       "configurableType": {
@@ -97,7 +97,7 @@
         "typeArguments": []
       },
       "name": "CONFIGURABLE_ENUM_B",
-      "offset": 3584
+      "offset": 3416
     },
     {
       "configurableType": {
@@ -106,7 +106,7 @@
         "typeArguments": null
       },
       "name": "ARRAY_BOOL",
-      "offset": 3496
+      "offset": 3328
     },
     {
       "configurableType": {
@@ -115,7 +115,7 @@
         "typeArguments": null
       },
       "name": "ARRAY_U64",
-      "offset": 3504
+      "offset": 3336
     },
     {
       "configurableType": {
@@ -124,7 +124,7 @@
         "typeArguments": null
       },
       "name": "TUPLE_BOOL_U64",
-      "offset": 3624
+      "offset": 3456
     },
     {
       "configurableType": {
@@ -133,7 +133,7 @@
         "typeArguments": null
       },
       "name": "STR_4",
-      "offset": 3616
+      "offset": 3448
     }
   ],
   "functions": [
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json
index 89dacf580b2..2daeaffdc6a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json
@@ -1,285 +1,228 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "c998ca9a5f221fe7b5c66ae70c8a9562b86d964408b00d17f883c906bc1fe4be",
+      "metadataTypeId": 0,
+      "type": "(bool, u64)"
+    },
+    {
+      "concreteTypeId": "4926d35d1a5157936b0a29bc126b8aace6d911209a5c130e9b716b0c73643ea6",
+      "metadataTypeId": 1,
+      "type": "[bool; 3]"
+    },
+    {
+      "concreteTypeId": "776fb5a3824169d6736138565fdc20aad684d9111266a5ff6d5c675280b7e199",
+      "metadataTypeId": 2,
+      "type": "[u64; 3]"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "a2922861f03be8a650595dd76455b95383a61b46dd418f02607fa2e00dc39d5c",
+      "metadataTypeId": 3,
+      "type": "enum ConfigurableEnum"
+    },
+    {
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
+      "type": "str[4]"
+    },
+    {
+      "concreteTypeId": "81fc10c4681a3271cf2d66b2ec6fbc8ed007a442652930844fcf11818c295bff",
+      "metadataTypeId": 4,
+      "type": "struct ConfigurableStruct"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [
     {
-      "configurableType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": null
-      },
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
       "name": "BOOL",
-      "offset": 6928
+      "offset": 6896
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      },
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
       "name": "U8",
-      "offset": 7064
+      "offset": 7088
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      },
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
       "name": "ANOTHER_U8",
-      "offset": 6856
+      "offset": 6824
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      },
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
       "name": "U16",
-      "offset": 7008
+      "offset": 7032
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 11,
-        "typeArguments": null
-      },
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
       "name": "U32",
-      "offset": 7048
+      "offset": 7072
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 11,
-        "typeArguments": null
-      },
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
       "name": "U64",
-      "offset": 7056
+      "offset": 7080
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      },
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
       "name": "U256",
-      "offset": 7016
+      "offset": 7040
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 4,
-        "typeArguments": null
-      },
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
       "name": "B256",
-      "offset": 6896
+      "offset": 6864
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 8,
-        "typeArguments": []
-      },
+      "concreteTypeId": "81fc10c4681a3271cf2d66b2ec6fbc8ed007a442652930844fcf11818c295bff",
       "name": "CONFIGURABLE_STRUCT",
-      "offset": 6968
+      "offset": 6984
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      },
+      "concreteTypeId": "a2922861f03be8a650595dd76455b95383a61b46dd418f02607fa2e00dc39d5c",
       "name": "CONFIGURABLE_ENUM_A",
-      "offset": 6936
+      "offset": 6904
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      },
+      "concreteTypeId": "a2922861f03be8a650595dd76455b95383a61b46dd418f02607fa2e00dc39d5c",
       "name": "CONFIGURABLE_ENUM_B",
-      "offset": 6952
+      "offset": 6944
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      },
+      "concreteTypeId": "4926d35d1a5157936b0a29bc126b8aace6d911209a5c130e9b716b0c73643ea6",
       "name": "ARRAY_BOOL",
-      "offset": 6864
+      "offset": 6832
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      },
+      "concreteTypeId": "776fb5a3824169d6736138565fdc20aad684d9111266a5ff6d5c675280b7e199",
       "name": "ARRAY_U64",
-      "offset": 6872
+      "offset": 6840
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      },
+      "concreteTypeId": "c998ca9a5f221fe7b5c66ae70c8a9562b86d964408b00d17f883c906bc1fe4be",
       "name": "TUPLE_BOOL_U64",
-      "offset": 6992
+      "offset": 7016
     },
     {
-      "configurableType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": null
-      },
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
       "name": "STR_4",
-      "offset": 6984
+      "offset": 7008
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "name": "NOT_USED",
+      "offset": 7000
     }
   ],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 5,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         },
         {
           "name": "__tuple_element",
-          "type": 12,
-          "typeArguments": null
+          "typeId": 5
         }
       ],
-      "type": "(_, _)",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 5,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         }
       ],
-      "type": "[_; 3]",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "[_; 3]"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 12,
-          "typeArguments": null
+          "typeId": 5
         }
       ],
-      "type": "[_; 3]",
-      "typeId": 3,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 4,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "[_; 3]"
     },
     {
       "components": [
         {
           "name": "A",
-          "type": 5,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         },
         {
           "name": "B",
-          "type": 12,
-          "typeArguments": null
+          "typeId": 5
+        },
+        {
+          "name": "C",
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "enum ConfigurableEnum",
-      "typeId": 6,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[4]",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "enum ConfigurableEnum"
     },
     {
       "components": [
         {
           "name": "a",
-          "type": 5,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         },
         {
           "name": "b",
-          "type": 12,
-          "typeArguments": null
+          "typeId": 5
         }
       ],
-      "type": "struct ConfigurableStruct",
-      "typeId": 8,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 9,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "struct ConfigurableStruct"
     },
     {
-      "components": null,
-      "type": "u256",
-      "typeId": 10,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 11,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 12,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 13,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "u64"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw
index 6e0e94ba5e1..c89257f717b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw
@@ -1,5 +1,5 @@
- script;
- 
+script;
+
 use std::hash::*;
 
 struct ConfigurableStruct {
@@ -10,6 +10,7 @@ struct ConfigurableStruct {
 enum ConfigurableEnum {
     A: bool,
     B: u64,
+    C: b256
 }
 
 impl core::ops::Eq for ConfigurableEnum {
@@ -24,8 +25,8 @@ impl core::ops::Eq for ConfigurableEnum {
 
 type AnotherU8 = u8;
 
- configurable {
-     BOOL: bool = true,
+configurable {
+    BOOL: bool = true,
     U8: u8 = 1,
     ANOTHER_U8: AnotherU8 = 3,
     U16: u16 = 2,
@@ -33,23 +34,23 @@ type AnotherU8 = u8;
     U64: u32 = 4,
     U256: u256 = 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu256,
     B256: b256 = 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,
-    CONFIGURABLE_STRUCT: ConfigurableStruct = ConfigurableStruct { 
-        a: true,
-        b: 5,
-    },
+    CONFIGURABLE_STRUCT: ConfigurableStruct = ConfigurableStruct { a: true, b: 5 },
     CONFIGURABLE_ENUM_A: ConfigurableEnum = ConfigurableEnum::A(true),
     CONFIGURABLE_ENUM_B: ConfigurableEnum = ConfigurableEnum::B(12),
     ARRAY_BOOL: [bool; 3] = [true, false, true],
     ARRAY_U64: [u64; 3] = [9, 8, 7],
     TUPLE_BOOL_U64: (bool, u64) = (true, 11),
     STR_4: str[4] = __to_str_array("abcd"),
- }
- 
- fn main() {
-     assert(BOOL == true);
+
+    NOT_USED: u8 = 1
+}
+
+fn main() {
+    assert(BOOL == true);
     assert(U8 == 1);
     assert(ANOTHER_U8 == 3);
     assert(U16 == 2);
+    assert(U32 == 3);
     assert(U64 == 4);
     assert(U256 == 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu256);
     assert(B256 == 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB);
@@ -75,4 +76,4 @@ type AnotherU8 = u8;
         addr: u64
     };
     assert(addr_1 == addr_2);
- }
\ No newline at end of file
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/test.toml
index be5373ea994..20e2ed5c383 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/test.toml
@@ -2,5 +2,21 @@ category = "run"
 expected_result = { action = "return", value = 0 }
 expected_result_new_encoding = { action = "return_data", value = "" }
 validate_abi = true
-expected_warnings = 6
+expected_warnings = 1
 unsupported_profiles = ["debug"]
+
+# check: $()ANOTHER_U8 8
+# check: $()ARRAY_BOOL 8
+# check: $()ARRAY_U64 24
+# check: $()B256 32
+# check: $()BOOL 8
+# check: $()CONFIGURABLE_ENUM_A 40
+# check: $()CONFIGURABLE_ENUM_B 40
+# check: $()CONFIGURABLE_STRUCT 16
+# check: $()NOT_USED 8
+# check: $()STR_4 8
+# check: $()TUPLE_BOOL_U64 16
+# check: $()U16 8
+# check: $()U256 32
+# check: $()U32 8
+# check: $()U64 8
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/Forc.lock
new file mode 100644
index 00000000000..464a5ea4506
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "configurable_dedup_decode"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-5BADD42D3D8D8FF8"
+
+[[package]]
+name = "std"
+source = "path+from-root-5BADD42D3D8D8FF8"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/Forc.toml
similarity index 82%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/Forc.toml
index 0c9f0acbdee..09b0b0c1893 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/Forc.toml
@@ -2,7 +2,7 @@
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "const_decl_with_call_path"
+name = "configurable_dedup_decode"
 
 [dependencies]
 std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/json_abi_oracle.json
new file mode 100644
index 00000000000..096b1d487c9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/json_abi_oracle.json
@@ -0,0 +1,284 @@
+{
+  "configurables": [
+    {
+      "configurableType": {
+        "name": "",
+        "type": 5,
+        "typeArguments": null
+      },
+      "name": "BOOL",
+      "offset": 3392
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 13,
+        "typeArguments": null
+      },
+      "name": "U8",
+      "offset": 3528
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 13,
+        "typeArguments": null
+      },
+      "name": "ANOTHER_U8",
+      "offset": 3320
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 9,
+        "typeArguments": null
+      },
+      "name": "U16",
+      "offset": 3472
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 11,
+        "typeArguments": null
+      },
+      "name": "U32",
+      "offset": 3512
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 11,
+        "typeArguments": null
+      },
+      "name": "U64",
+      "offset": 3520
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 10,
+        "typeArguments": null
+      },
+      "name": "U256",
+      "offset": 3480
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 4,
+        "typeArguments": null
+      },
+      "name": "B256",
+      "offset": 3360
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 8,
+        "typeArguments": []
+      },
+      "name": "CONFIGURABLE_STRUCT",
+      "offset": 3432
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 6,
+        "typeArguments": []
+      },
+      "name": "CONFIGURABLE_ENUM_A",
+      "offset": 3400
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 6,
+        "typeArguments": []
+      },
+      "name": "CONFIGURABLE_ENUM_B",
+      "offset": 3416
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 2,
+        "typeArguments": null
+      },
+      "name": "ARRAY_BOOL",
+      "offset": 3328
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 3,
+        "typeArguments": null
+      },
+      "name": "ARRAY_U64",
+      "offset": 3336
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 1,
+        "typeArguments": null
+      },
+      "name": "TUPLE_BOOL_U64",
+      "offset": 3456
+    },
+    {
+      "configurableType": {
+        "name": "",
+        "type": 7,
+        "typeArguments": null
+      },
+      "name": "STR_4",
+      "offset": 3448
+    }
+  ],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": [],
+      "type": "()",
+      "typeId": 0,
+      "typeParameters": null
+    },
+    {
+      "components": [
+        {
+          "name": "__tuple_element",
+          "type": 5,
+          "typeArguments": null
+        },
+        {
+          "name": "__tuple_element",
+          "type": 12,
+          "typeArguments": null
+        }
+      ],
+      "type": "(_, _)",
+      "typeId": 1,
+      "typeParameters": null
+    },
+    {
+      "components": [
+        {
+          "name": "__array_element",
+          "type": 5,
+          "typeArguments": null
+        }
+      ],
+      "type": "[_; 3]",
+      "typeId": 2,
+      "typeParameters": null
+    },
+    {
+      "components": [
+        {
+          "name": "__array_element",
+          "type": 12,
+          "typeArguments": null
+        }
+      ],
+      "type": "[_; 3]",
+      "typeId": 3,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "b256",
+      "typeId": 4,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "bool",
+      "typeId": 5,
+      "typeParameters": null
+    },
+    {
+      "components": [
+        {
+          "name": "A",
+          "type": 5,
+          "typeArguments": null
+        },
+        {
+          "name": "B",
+          "type": 12,
+          "typeArguments": null
+        }
+      ],
+      "type": "enum ConfigurableEnum",
+      "typeId": 6,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "str[4]",
+      "typeId": 7,
+      "typeParameters": null
+    },
+    {
+      "components": [
+        {
+          "name": "a",
+          "type": 5,
+          "typeArguments": null
+        },
+        {
+          "name": "b",
+          "type": 12,
+          "typeArguments": null
+        }
+      ],
+      "type": "struct ConfigurableStruct",
+      "typeId": 8,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u16",
+      "typeId": 9,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u256",
+      "typeId": 10,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u32",
+      "typeId": 11,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 12,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u8",
+      "typeId": 13,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..b5e886d1a19
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/json_abi_oracle_new_encoding.json
@@ -0,0 +1,228 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "c998ca9a5f221fe7b5c66ae70c8a9562b86d964408b00d17f883c906bc1fe4be",
+      "metadataTypeId": 0,
+      "type": "(bool, u64)"
+    },
+    {
+      "concreteTypeId": "4926d35d1a5157936b0a29bc126b8aace6d911209a5c130e9b716b0c73643ea6",
+      "metadataTypeId": 1,
+      "type": "[bool; 3]"
+    },
+    {
+      "concreteTypeId": "776fb5a3824169d6736138565fdc20aad684d9111266a5ff6d5c675280b7e199",
+      "metadataTypeId": 2,
+      "type": "[u64; 3]"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "a2922861f03be8a650595dd76455b95383a61b46dd418f02607fa2e00dc39d5c",
+      "metadataTypeId": 3,
+      "type": "enum ConfigurableEnum"
+    },
+    {
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
+      "type": "str[4]"
+    },
+    {
+      "concreteTypeId": "81fc10c4681a3271cf2d66b2ec6fbc8ed007a442652930844fcf11818c295bff",
+      "metadataTypeId": 4,
+      "type": "struct ConfigurableStruct"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
+  "configurables": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "name": "BOOL",
+      "offset": 7216
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "name": "U8",
+      "offset": 7408
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "name": "ANOTHER_U8",
+      "offset": 7144
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "name": "U16",
+      "offset": 7352
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "name": "U32",
+      "offset": 7392
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "name": "U64",
+      "offset": 7400
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "name": "U256",
+      "offset": 7360
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "name": "B256",
+      "offset": 7184
+    },
+    {
+      "concreteTypeId": "81fc10c4681a3271cf2d66b2ec6fbc8ed007a442652930844fcf11818c295bff",
+      "name": "CONFIGURABLE_STRUCT",
+      "offset": 7304
+    },
+    {
+      "concreteTypeId": "a2922861f03be8a650595dd76455b95383a61b46dd418f02607fa2e00dc39d5c",
+      "name": "CONFIGURABLE_ENUM_A",
+      "offset": 7224
+    },
+    {
+      "concreteTypeId": "a2922861f03be8a650595dd76455b95383a61b46dd418f02607fa2e00dc39d5c",
+      "name": "CONFIGURABLE_ENUM_B",
+      "offset": 7264
+    },
+    {
+      "concreteTypeId": "4926d35d1a5157936b0a29bc126b8aace6d911209a5c130e9b716b0c73643ea6",
+      "name": "ARRAY_BOOL",
+      "offset": 7152
+    },
+    {
+      "concreteTypeId": "776fb5a3824169d6736138565fdc20aad684d9111266a5ff6d5c675280b7e199",
+      "name": "ARRAY_U64",
+      "offset": 7160
+    },
+    {
+      "concreteTypeId": "c998ca9a5f221fe7b5c66ae70c8a9562b86d964408b00d17f883c906bc1fe4be",
+      "name": "TUPLE_BOOL_U64",
+      "offset": 7336
+    },
+    {
+      "concreteTypeId": "94f0fa95c830be5e4f711963e83259fe7e8bc723278ab6ec34449e791a99b53a",
+      "name": "STR_4",
+      "offset": 7328
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "name": "NOT_USED",
+      "offset": 7320
+    }
+  ],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [
+    {
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 5
+        }
+      ],
+      "metadataTypeId": 0,
+      "type": "(_, _)"
+    },
+    {
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        }
+      ],
+      "metadataTypeId": 1,
+      "type": "[_; 3]"
+    },
+    {
+      "components": [
+        {
+          "name": "__array_element",
+          "typeId": 5
+        }
+      ],
+      "metadataTypeId": 2,
+      "type": "[_; 3]"
+    },
+    {
+      "components": [
+        {
+          "name": "A",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "B",
+          "typeId": 5
+        },
+        {
+          "name": "C",
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+        }
+      ],
+      "metadataTypeId": 3,
+      "type": "enum ConfigurableEnum"
+    },
+    {
+      "components": [
+        {
+          "name": "a",
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+        },
+        {
+          "name": "b",
+          "typeId": 5
+        }
+      ],
+      "metadataTypeId": 4,
+      "type": "struct ConfigurableStruct"
+    },
+    {
+      "metadataTypeId": 5,
+      "type": "u64"
+    }
+  ],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/snapshot.toml
new file mode 100644
index 00000000000..784ff71e177
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/snapshot.toml
@@ -0,0 +1 @@
+cmds = ["forc build --path {root} --release --ir final"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/src/main.sw
new file mode 100644
index 00000000000..74507d6d6ad
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/src/main.sw
@@ -0,0 +1,16 @@
+script;
+
+struct Wrapped {
+    v: u64,
+}
+
+// These types decode fns should coalesce into 
+// only one in the final IR
+configurable {
+    WRAPPED: Wrapped = Wrapped { v: 1 },
+    TUPLE: (u64,) = (2,),
+}
+
+fn main() -> u64 {
+    WRAPPED.v + TUPLE.0
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap
new file mode 100644
index 00000000000..283bf9e035f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap
@@ -0,0 +1,361 @@
+---
+source: test/tests/tests.rs
+---
+> forc build --path test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode --release --ir final
+exit status: 0
+output:
+    Building test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode
+   Compiling library core (sway-lib-core)
+   Compiling library std (sway-lib-std)
+// IR: Final
+library {
+}
+
+   Compiling script configurable_dedup_decode (test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode)
+// IR: Final
+script {
+    TUPLE = config { u64 }, abi_decode_in_place_0, 0x0000000000000002, !1
+    WRAPPED = config { u64 }, abi_decode_in_place_0, 0x0000000000000001, !2
+
+    pub fn abi_decode_in_place_0(ptr !4: u64, len !5: u64, target !6: u64) -> (), !10 {
+        local { u64 } __ret_val
+        local mut { u64 } buffer
+        local { u64 } temp
+
+        entry(ptr: u64, len: u64, target: u64):
+        v0 = get_local ptr { u64 }, __ret_val
+        v1 = call from_parts_1(ptr, len, v0)
+        v2 = const u64 0
+        v3 = get_elem_ptr v1, ptr u64, v2
+        v4 = load v3
+        v5 = get_local ptr { u64 }, buffer, !11
+        v6 = const u64 0
+        v7 = get_elem_ptr v5, ptr u64, v6
+        store v4 to v7
+        v8 = get_local ptr { u64 }, buffer, !12
+        v9 = call abi_decode_3(v8), !17
+        v10 = get_local ptr { u64 }, temp, !18
+        v11 = const u64 0
+        v12 = get_elem_ptr v10, ptr u64, v11
+        store v9 to v12
+        v13 = get_local ptr { u64 }, temp, !19
+        v14 = ptr_to_int v13 to u64, !20
+        v15 = const u64 8
+        v16 = asm(target: target, temp: v14, size: v15) -> (), !21 {
+            mcp    target temp size, !22
+        }
+        v17 = const unit ()
+        ret () v17
+    }
+
+    pub fn from_parts_1(ptr !23: u64, _len !24: u64, __ret_value: ptr { u64 }) -> ptr { u64 }, !27 {
+        entry(ptr: u64, _len: u64, __ret_value: ptr { u64 }):
+        v0 = const u64 0
+        v1 = get_elem_ptr __ret_value, ptr u64, v0
+        store ptr to v1
+        ret ptr { u64 } __ret_value
+    }
+
+    pub fn abi_decode_3(buffer !28: ptr { u64 }) -> u64, !31 {
+        entry(buffer: ptr { u64 }):
+        v0 = const u64 0
+        v1 = get_elem_ptr buffer, ptr u64, v0, !35
+        v2 = load v1, !36
+        v3 = asm(ptr: v2, val) -> u64 val, !38 {
+            lw     val ptr i0, !39
+        }
+        v4 = load v1, !36
+        v5 = const u64 8, !36
+        v6 = add v4, v5, !36
+        store v6 to v1, !41
+        ret u64 v3
+    }
+
+    pub entry fn __entry() -> ptr slice, !45 {
+        local mut { u64, u64, u64 } __aggr_memcpy_0
+        local mut { u64, u64, u64 } __aggr_memcpy_00
+        local mut { u64, u64, u64 } __aggr_memcpy_01
+        local mut { u64, u64, u64 } __aggr_memcpy_02
+        local mut slice __aggr_memcpy_03
+        local { u64, u64, u64 } __anon_0
+        local { u64, u64, u64 } __anon_00
+        local { u64, u64, u64 } __anon_01
+        local { { u64, u64, u64 } } __anon_1
+        local { u64, u64, u64 } __anon_10
+        local { u64, u64 } __anon_11
+        local { { u64, u64, u64 } } __anon_2
+        local { u64, u64, u64 } __asm_arg
+        local { u64, u64, u64 } __asm_arg0
+        local slice __ret_value
+        local { { u64, u64, u64 } } buffer
+
+        entry():
+        v0 = get_local ptr slice, __ret_value
+        v1 = call main_8(), !48
+        v2 = const u64 1024
+        v3 = asm(cap: v2) -> u64 hp, !53 {
+            aloc   cap
+        }
+        v4 = int_to_ptr v3 to ptr u8, !54
+        v5 = ptr_to_int v4 to u64, !55
+        v6 = get_local ptr { u64, u64, u64 }, __anon_0, !56
+        v7 = const u64 0
+        v8 = get_elem_ptr v6, ptr u64, v7, !57
+        store v5 to v8, !58
+        v9 = const u64 1
+        v10 = get_elem_ptr v6, ptr u64, v9, !59
+        store v2 to v10, !60
+        v11 = const u64 2
+        v12 = get_elem_ptr v6, ptr u64, v11, !61
+        v13 = const u64 0
+        store v13 to v12, !62
+        v14 = asm(buffer: v6) -> ptr { u64, u64, u64 } buffer {
+        }
+        v15 = get_local ptr { u64, u64, u64 }, __aggr_memcpy_0
+        mem_copy_val v15, v14
+        v16 = get_local ptr { { u64, u64, u64 } }, __anon_1, !64
+        v17 = const u64 0
+        v18 = get_elem_ptr v16, ptr { u64, u64, u64 }, v17, !65
+        mem_copy_val v18, v15
+        v19 = ptr_to_int v16 to u64, !68
+        v20 = int_to_ptr v19 to ptr { { u64, u64, u64 } }, !69
+        v21 = const u64 0
+        v22 = get_elem_ptr v20, ptr { u64, u64, u64 }, v21, !71
+        v23 = get_local ptr { u64, u64, u64 }, __asm_arg
+        mem_copy_val v23, v22
+        v24 = asm(buffer: v23) -> ptr { u64, u64, u64 } buffer {
+        }
+        v25 = get_local ptr { u64, u64, u64 }, __aggr_memcpy_00
+        mem_copy_val v25, v24
+        v26 = get_local ptr { u64, u64, u64 }, __anon_00, !72
+        mem_copy_val v26, v25
+        v27 = const u64 0
+        v28 = get_elem_ptr v26, ptr u64, v27, !73
+        v29 = load v28, !74
+        v30 = int_to_ptr v29 to ptr u8, !75
+        v31 = const u64 1
+        v32 = get_elem_ptr v26, ptr u64, v31, !76
+        v33 = load v32, !77
+        v34 = const u64 2
+        v35 = get_elem_ptr v26, ptr u64, v34, !78
+        v36 = load v35, !79
+        v37 = const u64 8
+        v38 = add v36, v37, !80
+        v39 = cmp gt v38 v33, !81
+        cbr v39, encode_10_abi_encode_11_block1(), encode_10_abi_encode_11_block0(v30, v33), !82
+
+        encode_10_abi_encode_11_block0(v40: ptr u8, v41: u64):
+        v42 = ptr_to_int v40 to u64, !83
+        v43 = add v42, v36, !84
+        v44 = int_to_ptr v43 to ptr u64, !85
+        store v1 to v44, !86
+        v45 = get_local ptr { u64, u64, u64 }, __anon_10, !87
+        v46 = const u64 0
+        v47 = get_elem_ptr v45, ptr u64, v46, !88
+        store v42 to v47, !89
+        v48 = const u64 1
+        v49 = get_elem_ptr v45, ptr u64, v48, !90
+        store v41 to v49, !91
+        v50 = const u64 2
+        v51 = get_elem_ptr v45, ptr u64, v50, !92
+        store v38 to v51, !93
+        v52 = asm(buffer: v45) -> ptr { u64, u64, u64 } buffer {
+        }
+        v53 = get_local ptr { u64, u64, u64 }, __aggr_memcpy_01
+        mem_copy_val v53, v52
+        v54 = get_local ptr { { u64, u64, u64 } }, __anon_2, !95
+        v55 = const u64 0
+        v56 = get_elem_ptr v54, ptr { u64, u64, u64 }, v55, !96
+        mem_copy_val v56, v53
+        v57 = get_local ptr { { u64, u64, u64 } }, buffer, !98
+        mem_copy_val v57, v54
+        v58 = get_local ptr { { u64, u64, u64 } }, buffer, !100
+        v59 = ptr_to_int v58 to u64, !103
+        v60 = int_to_ptr v59 to ptr { { u64, u64, u64 } }, !104
+        v61 = const u64 0
+        v62 = get_elem_ptr v60, ptr { u64, u64, u64 }, v61, !105
+        v63 = get_local ptr { u64, u64, u64 }, __asm_arg0
+        mem_copy_val v63, v62
+        v64 = asm(buffer: v63) -> ptr { u64, u64, u64 } buffer {
+        }
+        v65 = get_local ptr { u64, u64, u64 }, __aggr_memcpy_02
+        mem_copy_val v65, v64
+        v66 = get_local ptr { u64, u64, u64 }, __anon_01, !106
+        mem_copy_val v66, v65
+        v67 = const u64 0
+        v68 = get_elem_ptr v66, ptr u64, v67, !107
+        v69 = load v68, !108
+        v70 = int_to_ptr v69 to ptr u8, !109
+        v71 = const u64 2
+        v72 = get_elem_ptr v66, ptr u64, v71, !110
+        v73 = ptr_to_int v70 to u64, !111
+        v74 = get_local ptr { u64, u64 }, __anon_11, !112
+        v75 = const u64 0
+        v76 = get_elem_ptr v74, ptr u64, v75, !113
+        store v73 to v76, !114
+        v77 = const u64 1
+        v78 = get_elem_ptr v74, ptr u64, v77, !115
+        mem_copy_val v78, v72
+        v79 = asm(s: v74) -> ptr slice s {
+        }
+        v80 = get_local ptr slice, __aggr_memcpy_03
+        mem_copy_val v80, v79
+        mem_copy_val v0, v80
+        ret ptr slice v0
+
+        encode_10_abi_encode_11_block1():
+        v81 = const u64 2
+        v82 = mul v33, v81, !116
+        v83 = asm(new_cap: v82, old_ptr: v30, len: v36) -> ptr u8 hp, !117 {
+            aloc   new_cap
+            mcp    hp old_ptr len
+        }
+        br encode_10_abi_encode_11_block0(v83, v82), !118
+    }
+
+    entry_orig fn main_8() -> u64, !121 {
+        entry():
+        v0 = get_config ptr { u64 }, WRAPPED, !122
+        v1 = const u64 0
+        v2 = get_elem_ptr v0, ptr u64, v1, !123
+        v3 = load v2
+        v4 = get_config ptr { u64 }, TUPLE, !124
+        v5 = const u64 0
+        v6 = get_elem_ptr v4, ptr u64, v5, !125
+        v7 = load v6
+        v8 = add v3, v7, !128
+        ret u64 v8
+    }
+}
+
+!0 = "test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/src/main.sw"
+!1 = span !0 177 182
+!2 = span !0 136 143
+!3 = "sway-lib-core/src/codec.sw"
+!4 = span !3 64814 64817
+!5 = span !3 64828 64831
+!6 = span !3 64838 64844
+!7 = span !3 64784 65117
+!8 = fn_name_span !3 64791 64810
+!9 = inline "never"
+!10 = (!7 !8 !9)
+!11 = span !3 64885 64937
+!12 = span !3 64967 64973
+!13 = span !3 64953 64974
+!14 = fn_call_path_span !3 64953 64966
+!15 = span !3 102115 102136
+!16 = fn_call_path_span !3 102115 102128
+!17 = (!13 !14 !15 !16)
+!18 = span !3 64942 64975
+!19 = span !3 65033 65037
+!20 = span !3 65023 65038
+!21 = span !3 64980 65115
+!22 = span !3 65088 65108
+!23 = span !3 652 655
+!24 = span !3 666 670
+!25 = span !3 634 729
+!26 = fn_name_span !3 641 651
+!27 = (!25 !26)
+!28 = span !3 65527 65533
+!29 = span !3 65505 65600
+!30 = fn_name_span !3 65508 65518
+!31 = (!29 !30)
+!32 = span !3 65566 65594
+!33 = fn_call_path_span !3 65573 65585
+!34 = span !3 593 605
+!35 = (!32 !33 !34)
+!36 = (!32 !33)
+!37 = span !3 2734 2815
+!38 = (!32 !33 !37)
+!39 = span !3 2772 2785
+!40 = span !3 2825 2864
+!41 = (!32 !33 !40)
+!42 = "<autogenerated>"
+!43 = span !42 0 125
+!44 = fn_name_span !42 7 14
+!45 = (!43 !44)
+!46 = span !42 66 72
+!47 = fn_call_path_span !42 66 70
+!48 = (!46 !47)
+!49 = span !42 90 111
+!50 = fn_call_path_span !42 90 96
+!51 = span !3 64530 64543
+!52 = fn_call_path_span !3 64530 64541
+!53 = (!49 !50 !51 !52)
+!54 = (!49 !50 !51 !52)
+!55 = (!49 !50 !51 !52)
+!56 = (!49 !50 !51 !52)
+!57 = (!49 !50 !51 !52)
+!58 = (!49 !50 !51 !52)
+!59 = (!49 !50 !51 !52)
+!60 = (!49 !50 !51 !52)
+!61 = (!49 !50 !51 !52)
+!62 = (!49 !50 !51 !52)
+!63 = span !3 159 222
+!64 = (!49 !50 !51 !52 !63)
+!65 = (!49 !50 !51 !52)
+!66 = span !3 64514 64544
+!67 = fn_call_path_span !3 64519 64529
+!68 = (!49 !50 !66 !67)
+!69 = (!49 !50 !66 !67)
+!70 = span !3 55 82
+!71 = (!49 !50 !66 !67 !70)
+!72 = (!49 !50 !66 !67)
+!73 = (!49 !50 !66 !67)
+!74 = (!49 !50 !66 !67)
+!75 = (!49 !50 !66 !67)
+!76 = (!49 !50 !66 !67)
+!77 = (!49 !50 !66 !67)
+!78 = (!49 !50 !66 !67)
+!79 = (!49 !50 !66 !67)
+!80 = (!49 !50 !66 !67)
+!81 = (!49 !50 !66 !67)
+!82 = (!49 !50 !66 !67)
+!83 = (!49 !50 !66 !67)
+!84 = (!49 !50 !66 !67)
+!85 = (!49 !50 !66 !67)
+!86 = (!49 !50 !66 !67)
+!87 = (!49 !50 !66 !67)
+!88 = (!49 !50 !66 !67)
+!89 = (!49 !50 !66 !67)
+!90 = (!49 !50 !66 !67)
+!91 = (!49 !50 !66 !67)
+!92 = (!49 !50 !66 !67)
+!93 = (!49 !50 !66 !67)
+!94 = span !3 4684 4767
+!95 = (!49 !50 !66 !67 !94)
+!96 = (!49 !50 !66 !67)
+!97 = span !3 64501 64545
+!98 = (!49 !50 !97)
+!99 = span !3 64550 64556
+!100 = (!49 !50 !99)
+!101 = span !3 64550 64571
+!102 = fn_call_path_span !3 64557 64569
+!103 = (!49 !50 !101 !102)
+!104 = (!49 !50 !101 !102)
+!105 = (!49 !50 !101 !102 !70)
+!106 = (!49 !50 !101 !102)
+!107 = (!49 !50 !101 !102)
+!108 = (!49 !50 !101 !102)
+!109 = (!49 !50 !101 !102)
+!110 = (!49 !50 !101 !102)
+!111 = (!49 !50 !101 !102)
+!112 = (!49 !50 !101 !102)
+!113 = (!49 !50 !101 !102)
+!114 = (!49 !50 !101 !102)
+!115 = (!49 !50 !101 !102)
+!116 = (!49 !50 !66 !67)
+!117 = (!49 !50 !66 !67)
+!118 = (!49 !50 !66 !67)
+!119 = span !0 202 246
+!120 = fn_name_span !0 205 209
+!121 = (!119 !120)
+!122 = span !0 225 232
+!123 = span !0 30 36
+!124 = span !0 237 242
+!125 = span !0 243 244
+!126 = span !0 225 244
+!127 = fn_call_path_span !0 235 236
+!128 = (!126 !127)
+
+    Finished release [optimized + fuel] target(s) [736 B] in ???
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_and_use_in_library/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_and_use_in_library/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_and_use_in_library/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_and_use_in_library/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/main.sw
index 08aec64bda0..192fa6ffda7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/main.sw
@@ -3,6 +3,7 @@ script;
 mod heaven;
 mod earth;
 mod hell;
+mod moon;
 
 use heaven::UNKNOWN_DEITY_VALUE;
 use earth::MAN;
@@ -19,8 +20,12 @@ fn god() -> u64 {
 use heaven::MONKEYS_GONE_HERE;
 
 fn main() -> bool {
-    if god() == 7 {
-        MONKEYS_GONE_HERE
+    if moon::WE_WERE_NEVER_HERE {
+        if god() == 7 {
+            MONKEYS_GONE_HERE
+        } else {
+            false
+        }
     } else {
         false
     }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/moon.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/moon.sw
new file mode 100644
index 00000000000..bb339df8151
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_in_library/src/moon.sw
@@ -0,0 +1,3 @@
+library;
+
+pub const WE_WERE_NEVER_HERE: bool = true;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/src/main.sw
deleted file mode 100644
index 6cb7e968704..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/src/main.sw
+++ /dev/null
@@ -1,8 +0,0 @@
-script;
-
-const GLOBAL_VAL: u64 = 99;
-
-fn main() -> u64 {
-    const LOCAL_VAL = 1;
-    GLOBAL_VAL + LOCAL_VAL
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/Forc.lock
deleted file mode 100644
index 49639c978a3..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/Forc.lock
+++ /dev/null
@@ -1,13 +0,0 @@
-[[package]]
-name = 'const_decl_with_call_path'
-source = 'member'
-dependencies = ['std']
-
-[[package]]
-name = 'core'
-source = 'path+from-root-8403A6B918C3B0C1'
-
-[[package]]
-name = 'std'
-source = 'path+from-root-8403A6B918C3B0C1'
-dependencies = ['core']
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/src/main.sw
deleted file mode 100644
index 74a0f848b79..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/src/main.sw
+++ /dev/null
@@ -1,13 +0,0 @@
-script;
-
-mod test_lib;
-
-fn main() -> u64 {
-    let x = test_lib::NUMBER;
-    let zero = b256::zero();
-    let base_asset_id = AssetId::base();
-    let base_asset_id_b256: b256 = base_asset_id.into();
-    assert(zero == 0x0000000000000000000000000000000000000000000000000000000000000000);
-    assert(base_asset_id_b256 == zero);
-    x
-}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/src/test_lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/src/test_lib.sw
deleted file mode 100644
index 2bdbcad65a1..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/src/test_lib.sw
+++ /dev/null
@@ -1,3 +0,0 @@
-library;
-
-pub const NUMBER: u64 = 10;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_inits/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_inits/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_inits/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/const_inits/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_caller_as_ret/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_caller_as_ret/json_abi_oracle_new_encoding.json
index ef7773fb592..25b210026bf 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_caller_as_ret/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_caller_as_ret/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "test_function",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/Forc.lock
new file mode 100644
index 00000000000..1502892f25d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "contract_calls_unwrapped_contract_id"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-A615F9B9DE584E81"
+
+[[package]]
+name = "std"
+source = "path+from-root-A615F9B9DE584E81"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/Forc.toml
new file mode 100644
index 00000000000..00360995cb3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+name = "contract_calls_unwrapped_contract_id"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/src/main.sw
new file mode 100644
index 00000000000..1ca64650c93
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/src/main.sw
@@ -0,0 +1,18 @@
+script;
+
+const ADDRESS: b256 = 0x000000000000000000000000000000000000000000000000000000000000002A;
+const IDENTITY: Identity = Identity::ContractId(ContractId::from(ADDRESS));
+
+abi MyAbi {
+    fn abi_method();
+}
+
+impl MyAbi for Contract {
+    fn abi_method() { }
+}
+
+fn main() -> u64 {
+    let caller = abi(MyAbi, IDENTITY.as_contract_id().unwrap().into());
+    caller.abi_method();
+    0
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/test.toml
new file mode 100644
index 00000000000..f52915a4c45
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_calls_unwrapped_contract_id/test.toml
@@ -0,0 +1,5 @@
+category = "compile"
+
+validate_abi = false
+validate_storage_slots = false
+expected_warnings = 2
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/Forc.lock
new file mode 100644
index 00000000000..9dfb581aa37
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "contract_implements_multiple_abis_with_same_methods"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-3480CC9F7FAAA8DF"
+
+[[package]]
+name = "std"
+source = "path+from-root-3480CC9F7FAAA8DF"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/Forc.toml
new file mode 100644
index 00000000000..5012bd4bf5e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "contract_implements_multiple_abis_with_same_methods"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/src/main.sw
new file mode 100644
index 00000000000..a2f67f680bc
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/src/main.sw
@@ -0,0 +1,31 @@
+contract;
+
+abi A {
+    fn foo() -> u64;
+}
+
+abi B {
+    fn foo() -> u64;
+}
+
+impl A for Contract {
+    fn foo() -> u64 {
+        3
+    }
+}
+
+impl B for Contract {
+    fn foo() -> u64 {
+        5
+    }
+}
+
+// TODO: Enable the asserts or adapt the tests once https://github.com/FuelLabs/sway/issues/6306 is implemented.
+#[test]
+fn test() {
+    let a = abi(A, CONTRACT_ID);
+    // assert_eq(3, a.foo());
+
+    let b = abi(B, CONTRACT_ID);
+    // assert_eq(5, b.foo());
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/test.toml
new file mode 100644
index 00000000000..0f3f6d7e866
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_implements_multiple_abis_with_same_methods/test.toml
@@ -0,0 +1 @@
+category = "unit_tests_pass"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/Forc.lock
new file mode 100644
index 00000000000..b5acd0aa565
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "contract_ret_intrinsic"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-793618C6A3B48D0B"
+
+[[package]]
+name = "std"
+source = "path+from-root-793618C6A3B48D0B"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/Forc.toml
new file mode 100644
index 00000000000..45d67307b35
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "contract_ret_intrinsic"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/src/main.sw
new file mode 100644
index 00000000000..6db6e3ed434
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/src/main.sw
@@ -0,0 +1,34 @@
+contract;
+
+abi Abi {
+    fn return_via_contract_ret(x: u8) -> u64;
+}
+
+impl Abi for Contract {
+    fn return_via_contract_ret(x: u8) -> u64 {
+        match x {
+            1 => {
+                let ret: raw_slice = encode::<u64>(100);
+                __contract_ret(ret.ptr(), ret.len::<u8>());
+                __revert(100);
+            },
+            2 => {
+                let ret: raw_slice = encode::<u64>(200);
+                __contract_ret(ret.ptr(), ret.len::<u8>());
+                __revert(200);
+            },
+            _ => __revert(0xaaa),
+        }
+    }
+}
+
+#[test]
+fn test() {
+    let caller = abi(Abi, CONTRACT_ID);
+
+    let res = caller.return_via_contract_ret(1);
+    assert_eq(100, res);
+
+    let res = caller.return_via_contract_ret(2);
+    assert_eq(200, res);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/test.toml
new file mode 100644
index 00000000000..f1958c1b086
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/contract_ret_intrinsic/test.toml
@@ -0,0 +1 @@
+category = "unit_tests_pass"
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/src/main.sw
deleted file mode 100644
index 73a67d733cd..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/src/main.sw
+++ /dev/null
@@ -1,7 +0,0 @@
-contract;
-
-#[namespace(my_namespace)]
-storage {
-    v:u64 = 1,
-}
-
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/test.toml
deleted file mode 100644
index 95ae0a24996..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/test.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-category = "compile"
-
-# check: $()#[namespace(my_namespace)]
-# nextln: $()Attribute namespace is deprecated.
-# nextln: $()You can use namespaces inside storage:
-# nextln: $()storage {
-# nextln: $()my_storage_namespace {
-# nextln: $()field: u64 = 1,
-# nextln: $()}
-# nextln: $()}
-
-expected_warnings = 2
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/diverging_exprs/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/diverging_exprs/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/diverging_exprs/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/diverging_exprs/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/empty_method_initializer/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/empty_method_initializer/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/empty_method_initializer/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/empty_method_initializer/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_destructuring/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_destructuring/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_destructuring/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_destructuring/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let_large_type/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let_large_type/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let_large_type/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_if_let_large_type/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_in_fn_decl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_in_fn_decl/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_in_fn_decl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_in_fn_decl/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_init_fn_call/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_init_fn_call/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_init_fn_call/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_init_fn_call/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_instantiation/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_instantiation/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_instantiation/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_instantiation/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_padding/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_padding/json_abi_oracle_new_encoding.json
index b2f5dfdc6ff..e4d28997902 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_padding/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_padding/json_abi_oracle_new_encoding.json
@@ -1,100 +1,89 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "93720e77cde7ac793c849579230ed2eb10cd51d3634075b9932b66153e0abafd",
+      "metadataTypeId": 3,
+      "type": "enum TopLevelEnum"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "93720e77cde7ac793c849579230ed2eb10cd51d3634075b9932b66153e0abafd"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 1
         },
         {
           "name": "__tuple_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 1
         }
       ],
-      "type": "(_, _)",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     },
     {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "b256"
     },
     {
       "components": [
         {
           "name": "first",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 1
         },
         {
           "name": "second",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 5
         }
       ],
-      "type": "enum LowerLevelEnum",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "enum LowerLevelEnum"
     },
     {
       "components": [
         {
           "name": "first",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "second",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 4
         }
       ],
-      "type": "enum TopLevelEnum",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "enum TopLevelEnum"
     },
     {
       "components": [
         {
           "name": "first",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 5
         },
         {
           "name": "second",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
-      "type": "struct ThenAStruct",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "struct ThenAStruct"
     },
     {
-      "components": null,
-      "type": "u32",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "u32"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_type_inference/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_type_inference/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_type_inference/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_type_inference/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_variant_imports/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_variant_imports/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_variant_imports/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/enum_variant_imports/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_and_neq/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_and_neq/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_and_neq/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_and_neq/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_intrinsic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_intrinsic/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_intrinsic/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/eq_intrinsic/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/fallback_only/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/fallback_only/json_abi_oracle_new_encoding.json
index a6eb72514c0..d3062bbc070 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/fallback_only/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/fallback_only/json_abi_oracle_new_encoding.json
@@ -1,8 +1,11 @@
 {
+  "concreteTypes": [],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": []
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/fix_opcode_bug/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/fix_opcode_bug/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/fix_opcode_bug/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/fix_opcode_bug/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/for_loops/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/for_loops/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/for_loops/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/for_loops/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/funcs_with_generic_types/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/funcs_with_generic_types/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/funcs_with_generic_types/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/funcs_with_generic_types/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/Forc.lock
new file mode 100644
index 00000000000..fe603fe62ef
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-D73E65B1F4E48513"
+
+[[package]]
+name = "function_return_type_unification"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/Forc.toml
similarity index 79%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/Forc.toml
index 02d72431094..ebe0edcfda3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/Forc.toml
@@ -1,8 +1,8 @@
 [project]
+name = "function_return_type_unification"
 authors = ["Fuel Labs <contact@fuel.sh>"]
-license = "Apache-2.0"
-name = "const_decl_literal"
 entry = "main.sw"
+license = "Apache-2.0"
 
 [dependencies]
 core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/src/main.sw
new file mode 100644
index 00000000000..761b788e150
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/src/main.sw
@@ -0,0 +1,28 @@
+script;
+
+trait Build {
+    fn build() -> Self;
+}
+
+impl Build for u32 {
+    fn build() -> Self {
+        31
+    }
+}
+
+impl Build for u64 {
+    fn build() -> Self {
+        63
+    }
+}
+
+fn produce<T>() -> T
+where T: Build,
+{
+    T::build()
+}
+
+fn main() -> u32 {
+    let x: u32 = produce();
+    x
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/test.toml
new file mode 100644
index 00000000000..bdd8e5d330a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/function_return_type_unification/test.toml
@@ -0,0 +1,4 @@
+category = "run"
+expected_result = { action = "return", value = 31 }
+expected_result_new_encoding = { action = "return_data", value = "0000001f" }
+validate_abi = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_functions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_functions/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_functions/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_functions/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.lock
index ec32bff5749..66ff73a2cb8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.lock
@@ -1,13 +1,16 @@
 [[package]]
-name = 'core'
-source = 'path+from-root-DA3FEDB2AB26E552'
+name = "core"
+source = "path+from-root-DA3FEDB2AB26E552"
 
 [[package]]
-name = 'generic_impl_self'
-source = 'member'
-dependencies = ['std']
+name = "generic_impl_self"
+source = "member"
+dependencies = [
+    "core",
+    "std",
+]
 
 [[package]]
-name = 'std'
-source = 'path+from-root-DA3FEDB2AB26E552'
-dependencies = ['core']
+name = "std"
+source = "path+from-root-DA3FEDB2AB26E552"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.toml
index 6b5e5c22c7f..41c297ce82a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/Forc.toml
@@ -5,4 +5,5 @@ name = "generic_impl_self"
 entry = "main.sw"
 
 [dependencies]
+core = { path = "../../../../../../../sway-lib-core" }
 std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/src/main.sw
index c40a7312e06..52c478d163b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self/src/main.sw
@@ -212,9 +212,23 @@ fn generic_impl_self_test() {
     assert(u.first.value + u.second.value == 7u8);
 }
 
+use std::vec::*;
+
+impl<T> Vec<T> {
+    pub fn with(self, with_value: T) -> Self {
+        let mut inside_vec = self;
+        inside_vec.push(with_value);
+        inside_vec
+    }
+}
+
 fn main() -> u32 {
     generic_impl_self_test();
     result_impl_test();
 
+    // data must be Vec<u256>
+    let data = Vec::new().with(0x333u256).with(0x222u256);
+    assert(data.len() == 2);
+
     10u32
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/src/main.sw
index 13b6473eb73..4df22003a57 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_impl_self_where/src/main.sw
@@ -65,6 +65,25 @@ impl MyEq for Data3 {
   }
 }
 
+// This tests it is still possible to call generic methods
+// where its parent has constraints
+// https://github.com/FuelLabs/sway/issues/6384
+
+trait MyTrait { }
+struct S<T> { }
+
+struct M1 {}
+impl MyTrait for M1 { }
+
+impl<T> S<T> where T: MyTrait {
+  fn bar<M>() {
+  }
+}
+
+fn issue_6384() {
+  let _x = S::<M1>::bar::<M1>();
+}
+
 fn main() -> u64 {
   let s = Data { x: 42 };
   assert(s.contains(42));
@@ -116,5 +135,7 @@ fn main() -> u64 {
   assert(!d4.contains5(Data2 { x: 41, y: Data3 { x: 42 } }));
   */
 
+  issue_6384();
+
   10
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_inside_generic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_inside_generic/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_inside_generic/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_inside_generic/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_result_method/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_result_method/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_result_method/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_result_method/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_struct/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_struct/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_structs/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_structs/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_structs/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_structs/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_trait_constraints/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_trait_constraints/src/main.sw
index 379224f8925..0073e0ea9d7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_trait_constraints/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_trait_constraints/src/main.sw
@@ -58,6 +58,21 @@ impl MyFrom<Struct4> for Struct3 {
     }
 }
 
+// call an associated function through generic constraints
+pub trait SizeInBytes {
+    fn size() -> u64;
+}
+
+impl SizeInBytes for u64 {
+    fn size() -> u64 {
+        8
+    }
+}
+
+fn call_size<T>() -> u64 where T: SizeInBytes {
+    T::size()
+}
+
 fn main() -> bool {
     let s1 = Struct {data: 1_u64 };
     assert_eq(s1.data.my_add(1,2),3);
@@ -72,5 +87,8 @@ fn main() -> bool {
     let s4: Struct3 = Struct4{data:42}.my_into();
     assert_eq(s4.data,42);
 
+    // call an associated function through generic constraints
+    assert_eq(call_size::<u64>(), 8);
+
     true
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_traits/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_traits/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_traits/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_traits/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_transpose/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_transpose/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_transpose/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_transpose/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_tuple_trait/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_tuple_trait/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_tuple_trait/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_tuple_trait/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_type_inference/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_type_inference/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_type_inference/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_type_inference/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self2/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self2/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self2/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/generic_where_in_impl_self2/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/src/main.sw
index c02e50d0010..9f494313fee 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/gtf_intrinsic/src/main.sw
@@ -4,7 +4,7 @@ use std::tx::*;
 
 fn main() -> u64 {
     assert(tx_witnesses_count() == 3);
-    assert(tx_witness_data::<u8>(1) == 1);
-    assert(tx_witness_data::<u64>(2) == 1234);
+    assert(tx_witness_data::<u8>(1).unwrap() == 1);
+    assert(tx_witness_data::<u64>(2).unwrap() == 1234);
     0
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/if_elseif_enum/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/if_elseif_enum/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/if_elseif_enum/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/if_elseif_enum/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/if_implicit_unit/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/if_implicit_unit/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/if_implicit_unit/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/if_implicit_unit/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/if_let_no_side_effects/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/if_let_no_side_effects/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/if_let_no_side_effects/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/if_let_no_side_effects/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_casting/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_casting/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_casting/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_casting/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_return/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_return/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_return/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/implicit_return/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/Forc.lock
similarity index 50%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/Forc.lock
index c5f965e3896..6a0e40e7180 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/Forc.lock
@@ -1,8 +1,8 @@
 [[package]]
-name = "associated_const_abi_default"
-source = "member"
-dependencies = ["core"]
+name = "core"
+source = "path+from-root-044245A29CAD6C26"
 
 [[package]]
-name = "core"
-source = "path+from-root-4DE28390654F2914"
+name = "import_from_private_ancestor"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/Forc.toml
similarity index 82%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/Forc.toml
index 903ebc9ae72..91a266c2b48 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/Forc.toml
@@ -1,8 +1,8 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
-entry = "main.sw"
 license = "Apache-2.0"
-name = "associated_const_abi_default"
+name = "import_from_private_ancestor"
+entry = "main.sw"
 implicit-std = false
 
 [dependencies]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/json_abi_oracle.json
new file mode 100644
index 00000000000..03b2f150939
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "bool",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..668a88f2e07
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz.sw
new file mode 100644
index 00000000000..2580c25454e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz.sw
@@ -0,0 +1,3 @@
+library;
+
+mod foo;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo.sw
new file mode 100644
index 00000000000..871fba91f2b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo.sw
@@ -0,0 +1,3 @@
+library;
+
+mod bar;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo/bar.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo/bar.sw
new file mode 100644
index 00000000000..df6056f61ce
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo/bar.sw
@@ -0,0 +1,3 @@
+library;
+
+mod baz;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo/bar/baz.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo/bar/baz.sw
new file mode 100644
index 00000000000..8ef39f15bcd
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/foz/foo/bar/baz.sw
@@ -0,0 +1,4 @@
+library;
+
+// This is legal even though foo is a private module, because foo is an ancestor of the current module
+use ::foz::foo::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/main.sw
new file mode 100644
index 00000000000..bd91906df81
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/src/main.sw
@@ -0,0 +1,3 @@
+library;
+
+mod foz;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/test.toml
new file mode 100644
index 00000000000..2c5bf1ae09a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_from_private_ancestor/test.toml
@@ -0,0 +1,2 @@
+category = "compile"
+expected_warnings = 0
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_method_from_other_file/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_method_from_other_file/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_method_from_other_file/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_method_from_other_file/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_star_name_clash/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_star_name_clash/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_star_name_clash/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_star_name_clash/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_trailing_comma/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_trailing_comma/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_trailing_comma/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_trailing_comma/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_with_different_callpaths/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_with_different_callpaths/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/import_with_different_callpaths/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/import_with_different_callpaths/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/impure_ifs/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/impure_ifs/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/impure_ifs/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/impure_ifs/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/inline_if_expr_const/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/inline_if_expr_const/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/inline_if_expr_const/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/inline_if_expr_const/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/insert_element_reg_reuse/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/insert_element_reg_reuse/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/insert_element_reg_reuse/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/insert_element_reg_reuse/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/integer_type_inference/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/integer_type_inference/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/integer_type_inference/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/integer_type_inference/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/is_prime/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/is_prime/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/is_prime/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/is_prime/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/is_reference_type/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/is_reference_type/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/is_reference_type/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/is_reference_type/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/left_to_right_func_args_evaluation/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/left_to_right_func_args_evaluation/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/left_to_right_func_args_evaluation/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/left_to_right_func_args_evaluation/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/local_impl_for_ord/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/local_impl_for_ord/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/local_impl_for_ord/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/local_impl_for_ord/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/logging/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/logging/json_abi_oracle_new_encoding.json
index 8af65bf6ec9..542c8009c36 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/logging/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/logging/json_abi_oracle_new_encoding.json
@@ -1,171 +1,147 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "469b6a3ae1aee813b2c73788d36a1e8dd84089a16afa4d87d726f87eea55a219",
+      "metadataTypeId": 1,
+      "type": "enum E"
+    },
+    {
+      "concreteTypeId": "4d1a8e2800ffb1d7af9edbf4e885657c6b930a0fe4596dec7297f2d0f064ebb5",
+      "type": "struct CustomAbiEncode"
+    },
+    {
+      "concreteTypeId": "3f8dc98862e8f3a9b179125e425353ebec6c0f5fc639afce8ed40456c21d3c62",
+      "metadataTypeId": 5,
+      "type": "struct S"
+    },
+    {
+      "concreteTypeId": "e5e8538f6cad3ebdae70cc8ba333e874c75e6478b85ac050988823aaf5fd81e2",
+      "metadataTypeId": 6,
+      "type": "struct SS<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "4579537983717831593",
-      "loggedType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      }
-    },
-    {
-      "logId": "16566583104751091389",
-      "loggedType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 13,
-            "typeArguments": null
-          }
-        ]
-      }
-    },
-    {
-      "logId": "5087777005172090899",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": []
-      }
-    },
-    {
-      "logId": "5555909392781521367",
-      "loggedType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": []
-      }
+      "concreteTypeId": "3f8dc98862e8f3a9b179125e425353ebec6c0f5fc639afce8ed40456c21d3c62",
+      "logId": "4579537983717831593"
+    },
+    {
+      "concreteTypeId": "e5e8538f6cad3ebdae70cc8ba333e874c75e6478b85ac050988823aaf5fd81e2",
+      "logId": "16566583104751091389"
+    },
+    {
+      "concreteTypeId": "469b6a3ae1aee813b2c73788d36a1e8dd84089a16afa4d87d726f87eea55a219",
+      "logId": "5087777005172090899"
+    },
+    {
+      "concreteTypeId": "4d1a8e2800ffb1d7af9edbf4e885657c6b930a0fe4596dec7297f2d0f064ebb5",
+      "logId": "5555909392781521367"
     }
   ],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "A",
-          "type": 7,
           "typeArguments": [
             {
               "name": "",
-              "type": 13,
-              "typeArguments": null
+              "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
             }
-          ]
+          ],
+          "typeId": 6
         },
         {
           "name": "B",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "enum E",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "enum E"
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "generic T"
     },
     {
-      "components": null,
-      "type": "raw untyped ptr",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "raw untyped ptr"
     },
     {
-      "components": null,
-      "type": "str",
-      "typeId": 4,
-      "typeParameters": null
-    },
-    {
-      "components": [],
-      "type": "struct CustomAbiEncode",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "str"
     },
     {
       "components": [
         {
           "name": "a",
-          "type": 13,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "b",
-          "type": 12,
-          "typeArguments": null
+          "typeId": 11
         },
         {
           "name": "c",
-          "type": 10,
-          "typeArguments": null
+          "typeId": 9
         },
         {
           "name": "d",
-          "type": 14,
-          "typeArguments": null
+          "typeId": 12
         },
         {
           "name": "e",
-          "type": 9,
           "typeArguments": [
             {
               "name": "",
-              "type": 13,
-              "typeArguments": null
+              "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
             }
-          ]
+          ],
+          "typeId": 8
         },
         {
           "name": "f",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 4
         },
         {
           "name": "g",
-          "type": 11,
-          "typeArguments": null
+          "typeId": 10
         }
       ],
-      "type": "struct S",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "struct S"
     },
     {
       "components": [
         {
           "name": "ss",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
+      "metadataTypeId": 6,
       "type": "struct SS",
-      "typeId": 7,
       "typeParameters": [
         2
       ]
@@ -174,17 +150,15 @@
       "components": [
         {
           "name": "ptr",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 3
         },
         {
           "name": "cap",
-          "type": 13,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 7,
       "type": "struct std::vec::RawVec",
-      "typeId": 8,
       "typeParameters": [
         2
       ]
@@ -193,56 +167,42 @@
       "components": [
         {
           "name": "buf",
-          "type": 8,
           "typeArguments": [
             {
               "name": "",
-              "type": 2,
-              "typeArguments": null
+              "typeId": 2
             }
-          ]
+          ],
+          "typeId": 7
         },
         {
           "name": "len",
-          "type": 13,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 8,
       "type": "struct std::vec::Vec",
-      "typeId": 9,
       "typeParameters": [
         2
       ]
     },
     {
-      "components": null,
-      "type": "u16",
-      "typeId": 10,
-      "typeParameters": null
+      "metadataTypeId": 9,
+      "type": "u16"
     },
     {
-      "components": null,
-      "type": "u256",
-      "typeId": 11,
-      "typeParameters": null
+      "metadataTypeId": 10,
+      "type": "u256"
     },
     {
-      "components": null,
-      "type": "u32",
-      "typeId": 12,
-      "typeParameters": null
+      "metadataTypeId": 11,
+      "type": "u32"
     },
     {
-      "components": null,
-      "type": "u64",
-      "typeId": 13,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 14,
-      "typeParameters": null
+      "metadataTypeId": 12,
+      "type": "u8"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_empty/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_empty/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_empty/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_empty/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_generics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_generics/json_abi_oracle_new_encoding.json
index 7cf591df1b1..64d80ab9878 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_generics/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_generics/json_abi_oracle_new_encoding.json
@@ -1,89 +1,80 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "f0ea9e428f47d8b233443fc8f7d3bb5ad2ae35d5175e8c15f0f76b3459c9c080",
+      "metadataTypeId": 0,
+      "type": "(struct TwoGenerics<u64,u32>, struct OneGeneric<u8>)"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "input",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "f0ea9e428f47d8b233443fc8f7d3bb5ad2ae35d5175e8c15f0f76b3459c9c080",
+          "name": "input"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "f0ea9e428f47d8b233443fc8f7d3bb5ad2ae35d5175e8c15f0f76b3459c9c080"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 5,
           "typeArguments": [
             {
               "name": "",
-              "type": 7,
-              "typeArguments": null
+              "typeId": 7
             },
             {
               "name": "",
-              "type": 6,
-              "typeArguments": null
+              "typeId": 6
             }
-          ]
+          ],
+          "typeId": 5
         },
         {
           "name": "__tuple_element",
-          "type": 4,
           "typeArguments": [
             {
               "name": "",
-              "type": 8,
-              "typeArguments": null
+              "typeId": 8
             }
-          ]
+          ],
+          "typeId": 4
         }
       ],
-      "type": "(struct TwoGenerics, struct OneGeneric)",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "generic T"
     },
     {
-      "components": null,
-      "type": "generic U",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "generic U"
     },
     {
-      "components": null,
-      "type": "generic V",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "generic V"
     },
     {
       "components": [
         {
           "name": "a",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
+      "metadataTypeId": 4,
       "type": "struct OneGeneric",
-      "typeId": 4,
       "typeParameters": [
         2
       ]
@@ -92,45 +83,39 @@
       "components": [
         {
           "name": "b",
-          "type": 4,
           "typeArguments": [
             {
               "name": "",
-              "type": 1,
-              "typeArguments": null
+              "typeId": 1
             }
-          ]
+          ],
+          "typeId": 4
         },
         {
           "name": "c",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 3
         }
       ],
+      "metadataTypeId": 5,
       "type": "struct TwoGenerics",
-      "typeId": 5,
       "typeParameters": [
         1,
         3
       ]
     },
     {
-      "components": null,
-      "type": "u32",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "u32"
     },
     {
-      "components": null,
-      "type": "u64",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 7,
+      "type": "u64"
     },
     {
-      "components": null,
-      "type": "u8",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 8,
+      "type": "u8"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_one_u64/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_one_u64/json_abi_oracle_new_encoding.json
index 11eabcab880..92ddbbb270c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_one_u64/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_one_u64/json_abi_oracle_new_encoding.json
@@ -1,32 +1,28 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "baba",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "baba"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_predicate/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_predicate/test.toml
index e10f4d0e5d1..48682e2fde8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_predicate/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_predicate/test.toml
@@ -6,4 +6,3 @@ expected_result = { action = "return", value = 1 }
 validate_abi = true
 
 expected_result_new_encoding = { action = "return_data", value = "0000000000000001" }
-
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref/json_abi_oracle_new_encoding.json
index ec82fc196ce..a339f6ef46e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref/json_abi_oracle_new_encoding.json
@@ -1,44 +1,44 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+      "metadataTypeId": 0,
+      "type": "struct TestStruct"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "baba",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+          "name": "baba"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "val",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct TestStruct",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "struct TestStruct"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_copy/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_copy/json_abi_oracle_new_encoding.json
index cc3f79bbc62..611b6c13c6d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_copy/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_copy/json_abi_oracle_new_encoding.json
@@ -1,49 +1,48 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+      "metadataTypeId": 0,
+      "type": "struct TestStruct"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "baba",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+          "name": "baba"
         },
         {
-          "name": "keke",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "keke"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "val",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct TestStruct",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "struct TestStruct"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_ref/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_ref/json_abi_oracle_new_encoding.json
index b22a72cff8e..4320edea528 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_ref/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_ref_ref/json_abi_oracle_new_encoding.json
@@ -1,49 +1,48 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+      "metadataTypeId": 0,
+      "type": "struct TestStruct"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "baba",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+          "name": "baba"
         },
         {
-          "name": "keke",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "f662bc0a8cc3280d0e276822675f38d76d489e5b30f23542d6724ffb81d17030",
+          "name": "keke"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "val",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct TestStruct",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "struct TestStruct"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_two_u64/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_two_u64/json_abi_oracle_new_encoding.json
index 7379bbd3b90..44236844825 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_two_u64/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_two_u64/json_abi_oracle_new_encoding.json
@@ -1,37 +1,32 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "baba",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "baba"
         },
         {
-          "name": "keke",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "keke"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/json_abi_oracle_new_encoding.json
index 09b704fef9b..6d95b04580f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/json_abi_oracle_new_encoding.json
@@ -1,105 +1,91 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "329d9cd6cc55beaa7f1d12e6e1c141134cad14dc31d74d9e2e39c03144d18ba5",
+      "metadataTypeId": 1,
+      "type": "[(struct OpName, enum SignedNum); 2]"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "ops",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "329d9cd6cc55beaa7f1d12e6e1c141134cad14dc31d74d9e2e39c03144d18ba5",
+          "name": "ops"
         }
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 5,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "3647243719605075626",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "329d9cd6cc55beaa7f1d12e6e1c141134cad14dc31d74d9e2e39c03144d18ba5",
+      "logId": "3647243719605075626"
     }
   ],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 4
         },
         {
           "name": "__tuple_element",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
-      "type": "(_, _)",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "[_; 2]",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "[_; 2]"
     },
     {
       "components": [
         {
           "name": "Positive",
-          "type": 5,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "Negative",
-          "type": 5,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "enum SignedNum",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "enum SignedNum"
     },
     {
-      "components": null,
-      "type": "str[3]",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "str[3]"
     },
     {
       "components": [
         {
           "name": "val",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 3
         }
       ],
-      "type": "struct OpName",
-      "typeId": 4,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "struct OpName"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_returns_unit/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_returns_unit/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_returns_unit/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_returns_unit/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/many_stack_variables/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/many_stack_variables/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/many_stack_variables/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/many_stack_variables/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/Forc.lock
new file mode 100644
index 00000000000..3a555a8fe55
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/Forc.lock
@@ -0,0 +1,16 @@
+[[package]]
+name = "core"
+source = "path+from-root-0B4C76FF57814684"
+
+[[package]]
+name = "match_expressions_all"
+source = "member"
+dependencies = [
+    "core",
+    "std",
+]
+
+[[package]]
+name = "std"
+source = "path+from-root-0B4C76FF57814684"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/Forc.toml
similarity index 88%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/Forc.toml
index eaec31a928c..6d1dea0b55d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/Forc.toml
@@ -1,7 +1,7 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
 license = "Apache-2.0"
-name = "match_expressions"
+name = "match_expressions_all"
 entry = "main.sw"
 
 [dependencies]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..aab161b0506
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/src/main.sw
similarity index 64%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/src/main.sw
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/src/main.sw
index 689aaffc9b0..0a493b8bc16 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/src/main.sw
@@ -18,7 +18,17 @@ fn inc_i(ref mut i: u64) -> Struct {
     Struct { x: 21, y: 21, z: 1 }
 }
 
-fn main() -> u64 {
+#[inline(never)]
+fn return_match_on_str_slice(param: str) -> u64 {
+    match param {
+        "get_a" => { 1u64 },
+        "get_a_b" => { 2u64 },
+        "get_b" => { 3u64 },
+        _ => { 1000u64 },
+    }
+}
+
+fn main() {
     let x = match 8 {
         7 => { 4 },
         9 => { 5 },
@@ -86,8 +96,22 @@ fn main() -> u64 {
     };
     assert(i == 11);
 
-    match 42 {
+    let r = match 42 {
         0 => { 24 },
         foo => { foo },
-    }
+    };
+    assert(r == 42);
+
+    // string slice
+    assert(return_match_on_str_slice("") == 1000);
+    assert(return_match_on_str_slice("g") == 1000);
+    assert(return_match_on_str_slice("ge") == 1000);
+    assert(return_match_on_str_slice("get") == 1000);
+    assert(return_match_on_str_slice("get_") == 1000);
+    assert(return_match_on_str_slice("get_a") == 1);
+    assert(return_match_on_str_slice("get_a_") == 1000);
+    assert(return_match_on_str_slice("get_a_b") == 2);
+    assert(return_match_on_str_slice("get_b") == 3);
+    assert(return_match_on_str_slice("get_c") == 1000);
 }
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/test.toml
similarity index 57%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/test.toml
index 4ce10cccb80..8fb3859ce4c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_with_call_path/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/test.toml
@@ -1,4 +1,4 @@
 category = "run"
-expected_result = { action = "return", value = 10 }
-expected_result_new_encoding = { action = "return_data", value = "000000000000000A" }
+expected_result = { action = "return", value = 0 }
+expected_result_new_encoding = { action = "return_data", value = "" }
 validate_abi = true
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/in_structs.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/in_structs.sw
new file mode 100644
index 00000000000..30fc4af8cd2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/in_structs.sw
@@ -0,0 +1,203 @@
+library;
+
+use ::lib::return_me;
+
+use ::lib::LIB_X;
+use ::lib::LIB_Y as ALIAS_LIB_Y;
+
+const MOD_X: u64 = 8;
+
+const NUMBER_1: u64 = 7;
+const NUMBER_2: u64 = 14;
+const NUMBER_3: u64 = 5;
+
+const TRUE: bool = true;
+const FALSE: bool = false;
+
+struct S {
+    x: u64,
+    b: bool,
+}
+
+struct StructWithConstNames {
+    MOD_X: u64,
+    LOCAL_X: u64,
+    LIB_X: u64,
+    ALIAS_LIB_Y: u64,
+}
+
+pub fn test() {
+    let a = match return_me(S { x: NUMBER_3, b: true }) {
+        S { x: NUMBER_1, b: _ } => 1,
+        S { x: NUMBER_2, b: _ } => 2,
+        S { x: NUMBER_3, b: _ } => 42,
+        _ => 1111,
+    };
+
+    assert_eq(a, 42);
+
+    let b = match return_me(S { x: 0, b: TRUE }) {
+        S { x: _, b: TRUE } => 42,
+        S { x: _, b: FALSE } => 3,
+    };
+    
+    assert_eq(b, 42);
+
+    const LOCAL_X: u64 = 13;
+
+    let c = match return_me(S { x: MOD_X, b: true }) {
+        S { x: MOD_X, b: _ } => {
+            42
+        },
+        S { x: LOCAL_X, b: _ } => {
+            4
+        },
+        S { x: LIB_X, b: _ } => {
+            5
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            6
+        },
+        _ => 2222,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: LOCAL_X, b: true }) {
+        S { x: MOD_X, b: _ } => {
+            7
+        },
+        S { x: LOCAL_X, b: _ } => {
+            42
+        },
+        S { x: LIB_X, b: _ } => {
+            8
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            9
+        },
+        _ => 3333,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: LIB_X, b: true }) {
+        S { x: MOD_X, b: _ } => {
+            10
+        },
+        S { x: LOCAL_X, b: _ } => {
+            11
+        },
+        S { x: LIB_X, b: _ } => {
+            42
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            12
+        },
+        _ => 4444,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: ALIAS_LIB_Y, b: true }) {
+        S { x: MOD_X, b: _ } => {
+            13
+        },
+        S { x: LOCAL_X, b: _ } => {
+            14
+        },
+        S { x: LIB_X, b: _ } => {
+            15
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            42
+        },
+        _ => 5555,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: MOD_X, b: true }) {
+        S { x: MOD_X, b: _ } | S { x: LOCAL_X, b: _ } | S { x: LIB_X, b: _ } => {
+            42
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            16
+        },
+        _ => 6666,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: LOCAL_X, b: true }) {
+        S { x: MOD_X, b: _ } | S { x: LOCAL_X, b: _ } | S { x: LIB_X, b: _ } => {
+            42
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            17
+        },
+        _ => 7777,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: LIB_X, b: true }) {
+        S { x: MOD_X, b: _ } | S { x: LOCAL_X, b: _ } | S { x: LIB_X, b: _ } => {
+            42
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            18
+        },
+        _ => 8888,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(S { x: ALIAS_LIB_Y, b: true }) {
+        S { x: MOD_X, b: _ } | S { x: LOCAL_X, b: _ } | S { x: LIB_X, b: _ } => {
+            19
+        },
+        S { x: ALIAS_LIB_Y, b: _ } => {
+            42
+        },
+        _ => 9999,
+    };
+    
+    assert_eq(c, 42);
+
+    let s = StructWithConstNames {
+        MOD_X,
+        LOCAL_X,
+        LIB_X,
+        ALIAS_LIB_Y,
+    };
+
+    let c = match return_me(s) {
+        StructWithConstNames { MOD_X: 0u64, LOCAL_X: _, LIB_X: _, ALIAS_LIB_Y: _ } => {
+            20
+        },
+        StructWithConstNames { MOD_X: MOD_X, LOCAL_X: LOCAL_X, LIB_X: LIB_X, ALIAS_LIB_Y: ALIAS_LIB_Y } => {
+            42
+        },
+        _ => 9999,
+    };
+
+    let s = StructWithConstNames {
+        MOD_X: 0,
+        LOCAL_X: 0,
+        LIB_X: 0,
+        ALIAS_LIB_Y: 0,
+    };
+
+    let c = match return_me(s) {
+        StructWithConstNames { MOD_X: MOD_X, LOCAL_X: LOCAL_X, LIB_X: LIB_X, ALIAS_LIB_Y: ALIAS_LIB_Y } => {
+            21
+        },
+        StructWithConstNames { MOD_X: 0u64, LOCAL_X: 0u64, LIB_X: 0u64, ALIAS_LIB_Y: 0u64 } => {
+            42
+        },
+        _ => 10000,
+    };
+    
+    assert_eq(c, 42);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/lib.sw
index 09f06e62d38..633356dd214 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/lib.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/lib.sw
@@ -1,4 +1,8 @@
 library;
 
-pub const LIB_X = 1021;
-pub const LIB_Y = 1034;
+pub const LIB_X: u64 = 1021;
+pub const LIB_Y: u64 = 1034;
+
+pub fn return_me<T>(x: T) -> T {
+    x
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/main.sw
index 16e2a8600da..ffa92ace5e7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/main.sw
@@ -1,161 +1,11 @@
 script;
 
 mod lib;
-
-use ::lib::LIB_X;
-use ::lib::LIB_Y as ALIAS_LIB_Y;
-
-const MOD_X = 8;
-
-const NUMBER_1: u64 = 7;
-const NUMBER_2: u64 = 14;
-const NUMBER_3: u64 = 5;
-
-const TRUE: bool = true;
-const FALSE: bool = false;
+mod top_level;
+mod in_structs;
 
 fn main() -> u64 {
-    let a = match return_me(NUMBER_3) {
-        NUMBER_1 => 1,
-        NUMBER_2 => 1,
-        NUMBER_3 => 42,
-        other => other,
-    };
-
-    assert(a == 42);
-
-    let b = match return_me(TRUE) {
-        TRUE => 42,
-        FALSE => 1,
-    };
-    
-    assert(b == 42);
-
-    const MAIN_X = 13;
-
-    let c = match return_me(MOD_X) {
-        MOD_X => {
-            42
-        },
-        MAIN_X => {
-            1
-        },
-        LIB_X => {
-            1
-        },
-        ALIAS_LIB_Y => {
-            1
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(MAIN_X) {
-        MOD_X => {
-            1
-        },
-        MAIN_X => {
-            42
-        },
-        LIB_X => {
-            1
-        },
-        ALIAS_LIB_Y => {
-            1
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(LIB_X) {
-        MOD_X => {
-            1
-        },
-        MAIN_X => {
-            1
-        },
-        LIB_X => {
-            42
-        },
-        ALIAS_LIB_Y => {
-            1
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(ALIAS_LIB_Y) {
-        MOD_X => {
-            1
-        },
-        MAIN_X => {
-            1
-        },
-        LIB_X => {
-            1
-        },
-        ALIAS_LIB_Y => {
-            42
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(MOD_X) {
-        MOD_X | MAIN_X | LIB_X => {
-            42
-        },
-        ALIAS_LIB_Y => {
-            1
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(MAIN_X) {
-        MOD_X | MAIN_X | LIB_X => {
-            42
-        },
-        ALIAS_LIB_Y => {
-            1
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(LIB_X) {
-        MOD_X | MAIN_X | LIB_X => {
-            42
-        },
-        ALIAS_LIB_Y => {
-            1
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    let c = match return_me(ALIAS_LIB_Y) {
-        MOD_X | MAIN_X | LIB_X => {
-            1
-        },
-        ALIAS_LIB_Y => {
-            42
-        },
-        _ => 9999,
-    };
-    
-    assert(c == 42);
-
-    a + b + c
+    ::top_level::test();
+    ::in_structs::test();
+    42
 }
-
-fn return_me<T>(x: T) -> T {
-    x
-}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/top_level.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/top_level.sw
new file mode 100644
index 00000000000..28875f81696
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/src/top_level.sw
@@ -0,0 +1,155 @@
+library;
+
+use ::lib::return_me;
+
+use ::lib::LIB_X;
+use ::lib::LIB_Y as ALIAS_LIB_Y;
+
+const MOD_X: u64 = 8;
+
+const NUMBER_1: u64 = 7;
+const NUMBER_2: u64 = 14;
+const NUMBER_3: u64 = 5;
+
+const TRUE: bool = true;
+const FALSE: bool = false;
+
+pub fn test() {
+    let a = match return_me(NUMBER_3) {
+        NUMBER_1 => 1,
+        NUMBER_2 => 2,
+        NUMBER_3 => 42,
+        other => other,
+    };
+
+    assert_eq(a, 42);
+
+    let b = match return_me(TRUE) {
+        TRUE => 42,
+        FALSE => 3,
+    };
+    
+    assert_eq(b, 42);
+
+    const LOCAL_X: u64 = 13;
+
+    let c = match return_me(MOD_X) {
+        MOD_X => {
+            42
+        },
+        LOCAL_X => {
+            4
+        },
+        LIB_X => {
+            5
+        },
+        ALIAS_LIB_Y => {
+            6
+        },
+        _ => 1111,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(LOCAL_X) {
+        MOD_X => {
+            7
+        },
+        LOCAL_X => {
+            42
+        },
+        LIB_X => {
+            8
+        },
+        ALIAS_LIB_Y => {
+            9
+        },
+        _ => 2222,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(LIB_X) {
+        MOD_X => {
+            10
+        },
+        LOCAL_X => {
+            11
+        },
+        LIB_X => {
+            42
+        },
+        ALIAS_LIB_Y => {
+            12
+        },
+        _ => 3333,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(ALIAS_LIB_Y) {
+        MOD_X => {
+            13
+        },
+        LOCAL_X => {
+            14
+        },
+        LIB_X => {
+            15
+        },
+        ALIAS_LIB_Y => {
+            42
+        },
+        _ => 4444,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(MOD_X) {
+        MOD_X | LOCAL_X | LIB_X => {
+            42
+        },
+        ALIAS_LIB_Y => {
+            16
+        },
+        _ => 5555,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(LOCAL_X) {
+        MOD_X | LOCAL_X | LIB_X => {
+            42
+        },
+        ALIAS_LIB_Y => {
+            17
+        },
+        _ => 6666,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(LIB_X) {
+        MOD_X | LOCAL_X | LIB_X => {
+            42
+        },
+        ALIAS_LIB_Y => {
+            18
+        },
+        _ => 7777,
+    };
+    
+    assert_eq(c, 42);
+
+    let c = match return_me(ALIAS_LIB_Y) {
+        MOD_X | LOCAL_X | LIB_X => {
+            19
+        },
+        ALIAS_LIB_Y => {
+            42
+        },
+        _ => 8888,
+    };
+    
+    assert_eq(c, 42);
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/test.toml
index 48fc96f6270..2e1e1832422 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/test.toml
@@ -1,5 +1,4 @@
 category = "run"
-expected_result = { action = "return", value = 126 }
-expected_result_new_encoding = { action = "return_data", value = "000000000000007E" }
-validate_abi = true
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
 expected_warnings = 1
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_empty_enums/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_empty_enums/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_empty_enums/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_empty_enums/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_enums/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_enums/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_enums/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_enums/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_inside_generic_functions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_inside_generic_functions/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_inside_generic_functions/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_inside_generic_functions/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_mismatched/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_mismatched/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_mismatched/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_mismatched/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_nested/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_nested/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_nested/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_nested/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_or/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_or/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_or/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_or/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_rest/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_rest/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_rest/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_rest/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_simple/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_simple/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_simple/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_simple/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_structs/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_structs/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_structs/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_structs/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/Forc.lock
new file mode 100644
index 00000000000..076f72c0d0a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-7FA7C6C8132DFBE7"
+
+[[package]]
+name = "match_expressions_unreachable_or"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/Forc.toml
new file mode 100644
index 00000000000..5f7f5b9d3f4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "match_expressions_unreachable_or"
+entry = "main.sw"
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/src/main.sw
new file mode 100644
index 00000000000..74fb30415ba
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/src/main.sw
@@ -0,0 +1,42 @@
+// This test proves that https://github.com/FuelLabs/sway/issues/6388 is fixed.
+script;
+
+struct S {
+    x: bool
+}
+
+fn main() {
+    let v = 0u64;
+    // We want to have only one error in the case below,
+    // for the whole or-pattern elements and not for individual
+    // parts.
+    match v {
+        1 => (),
+        1 | 1 => (),
+        _ => (),
+    };
+
+    match v {
+        1 => (),
+        2 => (),
+        1 | 2 => (),
+        _ => (),
+    };
+
+    // TODO: Once https://github.com/FuelLabs/sway/issues/5097 is fixed, the below examples
+    //       will also emit warnings for unreacahbility of individual or-pattern elements.
+    //       Extend filecheck checks to cover those warning.
+
+    match v {
+        1 => (),
+        2 => (),
+        1 | 3 => (),
+        2 | 4 => (),
+        _ => (),
+    };
+
+    let s = S { x: false };
+    let _x = match s {
+        S { x } | S { x } => { x },
+    };
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/test.toml
new file mode 100644
index 00000000000..c80a619ffe5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_unreachable_or/test.toml
@@ -0,0 +1,16 @@
+category = "compile"
+expected_warnings = 2
+
+#check: $()warning
+#sameln: $()Match arm is unreachable
+#check: $()1 => (),
+#nextln: $()Preceding match arms already match all the values that `1 | 1` can match.
+#check: $()1 | 1 => (),
+#nextln: $()Match arm `1 | 1` is unreachable.
+
+#check: $()warning
+#sameln: $()Match arm is unreachable
+#check: $()2 => (),
+#nextln: $()Preceding match arms already match all the values that `1 | 2` can match.
+#check: $()1 | 2 => (),
+#nextln: $()Match arm `1 | 2` is unreachable.
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_with_self/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_with_self/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_with_self/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_with_self/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/Forc.lock
new file mode 100644
index 00000000000..d279ad45f8d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-765123F2C684AE5A"
+
+[[package]]
+name = "method_nested_type_args"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-765123F2C684AE5A"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/Forc.toml
new file mode 100644
index 00000000000..9f43c4d89f5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "method_nested_type_args"
+entry = "main.sw"
+
+[dependencies]
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/src/main.sw
new file mode 100644
index 00000000000..47e8fee5518
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/src/main.sw
@@ -0,0 +1,26 @@
+script;
+
+trait T1 {}
+trait T2 {}
+
+struct S<T> where T: T1 {
+    x: T,
+}
+
+impl<T> S<T> where T: T1{
+    fn not_just_t1(self) -> u64 where T: T2  {
+        Self::also_t2(self)
+    }
+    fn also_t2(self) -> u64 where T: T2 {
+        42
+    }
+}
+
+impl T1 for u8 {}
+impl T1 for u64 {}
+impl T2 for u64 {}
+
+fn main() {
+    let a = S::<u64>{x: 42};
+	assert_eq(a.not_just_t1(), 42);
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/test.toml
similarity index 85%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/test.toml
index 09a31735c3e..4bffac353e9 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_abi_default/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_nested_type_args/test.toml
@@ -1,4 +1,5 @@
 category = "run"
 expected_result = { action = "return", value = 0 }
-expected_result_new_encoding = { action = "return_data", value = "00000000" }
+expected_result_new_encoding = { action = "return_data", value = "" }
+validate_abi = false
 expected_warnings = 1
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/method_on_empty_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_on_empty_struct/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/method_on_empty_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/method_on_empty_struct/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/modulo_uint_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/modulo_uint_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/modulo_uint_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/modulo_uint_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_impl_self/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_impl_self/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_impl_self/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_impl_self/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_item_import/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_item_import/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_item_import/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/multi_item_import/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/mut_ref_empty_type/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/mut_ref_empty_type/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/mut_ref_empty_type/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/mut_ref_empty_type/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_struct_destructuring/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_structs/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_structs/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_structs/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_structs/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_while_and_if/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_while_and_if/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_while_and_if/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/nested_while_and_if/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/new_allocator_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/new_allocator_test/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/new_allocator_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/new_allocator_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/non_literal_const_decl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/non_literal_const_decl/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/non_literal_const_decl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/non_literal_const_decl/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle.json
index 03b2f150939..4df01e84191 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle.json
@@ -12,7 +12,40 @@
       }
     }
   ],
-  "loggedTypes": [],
+  "loggedTypes": [
+    {
+      "logId": "1515152261580153489",
+      "loggedType": {
+        "name": "",
+        "type": 3,
+        "typeArguments": null
+      }
+    },
+    {
+      "logId": "15520703124961489725",
+      "loggedType": {
+        "name": "",
+        "type": 2,
+        "typeArguments": null
+      }
+    },
+    {
+      "logId": "2992671284987479467",
+      "loggedType": {
+        "name": "",
+        "type": 1,
+        "typeArguments": null
+      }
+    },
+    {
+      "logId": "14454674236531057292",
+      "loggedType": {
+        "name": "",
+        "type": 4,
+        "typeArguments": null
+      }
+    }
+  ],
   "messagesTypes": [],
   "types": [
     {
@@ -20,6 +53,30 @@
       "type": "bool",
       "typeId": 0,
       "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u16",
+      "typeId": 1,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u32",
+      "typeId": 2,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 3,
+      "typeParameters": null
+    },
+    {
+      "components": null,
+      "type": "u8",
+      "typeId": 4,
+      "typeParameters": null
     }
   ]
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle_new_encoding.json
index b89d516ddd1..9fcae28cf1f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/json_abi_oracle_new_encoding.json
@@ -1,26 +1,56 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
-  "loggedTypes": [],
-  "messagesTypes": [],
-  "types": [
+  "loggedTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "logId": "15520703124961489725"
+    },
     {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "logId": "2992671284987479467"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "logId": "14454674236531057292"
     }
-  ]
+  ],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/src/main.sw
index 855f039ded8..a9cb3b76873 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_constants/src/main.sw
@@ -1,19 +1,19 @@
 script;
 
 fn main() -> bool {
-    assert(u64::max() == 18446744073709551615u64);
-    assert(u64::min() == 0u64);
-    assert(u32::max() == 4294967295u32);
-    assert(u32::min() == 0u32);
-    assert(u16::max() == 65535u16);
-    assert(u16::min() == 0u16);
-    assert(u8::max() == 255u8);
-    assert(u8::min() == 0u8);
+    assert_eq(u64::max(), 18446744073709551615u64);
+    assert_eq(u64::min(), 0u64);
+    assert_eq(u32::max(), 4294967295u32);
+    assert_eq(u32::min(), 0u32);
+    assert_eq(u16::max(), 65535u16);
+    assert_eq(u16::min(), 0u16);
+    assert_eq(u8::max(), 255u8);
+    assert_eq(u8::min(), 0u8);
 
-    assert(u64::bits() == 64u64);
-    assert(u32::bits() == 32u64);
-    assert(u16::bits() == 16u64);
-    assert(u8::bits() == 8u64);
+    assert_eq(u64::bits(), 64u64);
+    assert_eq(u32::bits(), 32u64);
+    assert_eq(u16::bits(), 16u64);
+    assert_eq(u8::bits(), 8u64);
 
     true
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/Forc.lock
new file mode 100644
index 00000000000..c8d0134a5c1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-A2943394F152C9BB"
+
+[[package]]
+name = "numeric_type_propagation"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-A2943394F152C9BB"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/Forc.toml
new file mode 100644
index 00000000000..b84f7484a8b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+implicit-std = false
+license = "Apache-2.0"
+name = "numeric_type_propagation"
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/src/main.sw
new file mode 100644
index 00000000000..9dac838621b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/src/main.sw
@@ -0,0 +1,74 @@
+script;
+
+trait MyTrait{
+    fn foo(ref mut self) -> u64;
+}
+
+impl MyTrait for u64 {
+    fn foo(ref mut self) -> u64 {
+        64
+    }
+}
+impl MyTrait for u32 {
+    fn foo(ref mut self) -> u64 {
+        32
+    }
+}
+
+impl u64 {
+    fn baz(self) -> u64 {
+        64
+    }
+}
+impl u32 {
+    fn baz(self) -> u64{
+        32
+    }
+}
+
+fn bar<T>(ref mut x: T) -> u64 where T: MyTrait {
+    x.foo()
+}
+
+fn main() -> bool {
+    let mut a = 0; // depth 1 type propagation
+    let mut b = 0; // depth 2 type propagation
+    let mut c = 0; // depth 3 type propagation
+    assert_eq(bar(a), 32);
+    assert_eq(bar(b), 32);
+    assert_eq(bar(c), 32);
+    {
+        c = b;
+    }
+    {
+        b = a;
+    }
+    {
+        let _: &u32 = &a;
+    }
+    assert_eq(a.baz(), 32);
+    assert_eq(b.baz(), 32);
+    assert_eq(c.baz(), 32);
+    {   // Test inside nested code block
+        let mut a = 0; // depth 1 type propagation
+        let mut b = 0; // depth 2 type propagation
+        let mut c = 0; // depth 3 type propagation
+        assert_eq(bar(a), 32);
+        assert_eq(bar(b), 32);
+        assert_eq(bar(c), 32);
+        {
+            c = b;
+        }
+        {
+            b = a;
+        }
+        {
+            let _: &u32 = &a;
+        }
+        assert_eq(a.baz(), 32);
+        assert_eq(b.baz(), 32);
+        assert_eq(c.baz(), 32);
+    }
+
+    true
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/test.toml
similarity index 86%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/test.toml
index 96a7137e198..28fb5e56e0c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_trait_const/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/numeric_type_propagation/test.toml
@@ -1,4 +1,4 @@
 category = "run"
 expected_result = { action = "return", value = 1 }
 expected_result_new_encoding = { action = "return_data", value = "01" }
-expected_warnings = 1
+expected_warnings = 5
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/op_precedence/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/op_precedence/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/op_precedence/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/op_precedence/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ops/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ops/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ops/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ops/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/out_of_order_decl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/out_of_order_decl/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/out_of_order_decl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/out_of_order_decl/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access2/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access2/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access2/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/prelude_access2/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/primitive_type_argument/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/primitive_type_argument/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/primitive_type_argument/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/primitive_type_argument/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/raw_identifiers/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/raw_identifiers/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/raw_identifiers/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/raw_identifiers/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reassignment_operators/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reassignment_operators/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/reassignment_operators/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reassignment_operators/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/redundant_return/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/redundant_return/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/redundant_return/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/redundant_return/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/Forc.lock
new file mode 100755
index 00000000000..2f79b915015
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "aliases"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "core"
+source = "path+from-root-D05BA88A39195D06"
+
+[[package]]
+name = "std"
+source = "path+from-root-D05BA88A39195D06"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/Forc.toml
new file mode 100755
index 00000000000..5e3bdd0c704
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "aliases"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_2.sw
new file mode 100755
index 00000000000..1fa9465b0ec
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub enum Items2_Variants {
+    Z: u64,
+    W: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_3.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_3.sw
new file mode 100755
index 00000000000..cbc06d1bdc4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_3.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items3_Struct {
+    pub c: u64,
+}
+
+pub enum Items3_Enum {
+    E: u64,
+    F: u64,
+}
+
+pub enum Items3_Variants {
+    U: u64,
+    V: u64,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 13278;
+
+pub fn items_3_function() -> u64 {
+    ITEMS_3_FUNCTION_RES
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_4.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_4.sw
new file mode 100755
index 00000000000..809d49cc952
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/items_4.sw
@@ -0,0 +1,21 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: u64,
+}
+
+pub enum Items4_Enum {
+    G: u64,
+    H: u64,
+}
+
+pub enum Items4_Variants {
+    S: u64,
+    T: u64,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 14278;
+
+pub fn items_4_function() -> u64 {
+    ITEMS_4_FUNCTION_RES
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_1.sw
new file mode 100644
index 00000000000..d40aca7a5f1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct as Alias1_Struct;
+
+pub use ::items_1::Items1_Enum as Alias1_Enum;
+
+pub use ::items_1::Items1_Variants::X as Alias1_X;
+pub use ::items_1::Items1_Variants::Y as Alias1_Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES as ALIAS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function as alias_1_function;
+
+pub use ::items_1::Items1Trait as Alias1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_2.sw
new file mode 100644
index 00000000000..26b2411e634
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_2::Items2_Struct as Alias2_Struct;
+
+pub use ::items_2::Items2_Enum as Alias2_Enum;
+
+pub use ::items_2::Items2_Variants::Z as Alias2_Z;
+pub use ::items_2::Items2_Variants::W as Alias2_W;
+
+pub use ::items_2::ITEMS_2_FUNCTION_RES as ALIAS_2_FUNCTION_RES;
+
+pub use ::items_2::items_2_function as alias_2_function;
+
+pub use ::items_2::Items2Trait as Alias2Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_3_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_3_1.sw
new file mode 100644
index 00000000000..9476211085e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_3_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_3::Items3_Struct as Alias3_Struct;
+
+pub use ::items_3::Items3_Enum as Alias3_Enum;
+
+pub use ::items_3::Items3_Variants::U as Alias3_U;
+pub use ::items_3::Items3_Variants::V as Alias3_V;
+
+pub use ::items_3::ITEMS_3_FUNCTION_RES as ALIAS_3_FUNCTION_RES;
+
+pub use ::items_3::items_3_function as alias_3_function;
+
+pub use ::items_3::Items3Trait as Alias3Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_3_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_3_2.sw
new file mode 100644
index 00000000000..c6d2e169293
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_3_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::lib_3_1::Alias3_Struct as AltAlias3_Struct;
+
+pub use ::lib_3_1::Alias3_Enum as AltAlias3_Enum;
+
+pub use ::lib_3_1::Alias3_U as AltAlias3_U;
+pub use ::lib_3_1::Alias3_V as AltAlias3_V;
+
+pub use ::lib_3_1::ALIAS_3_FUNCTION_RES as ALTALIAS_3_FUNCTION_RES;
+
+pub use ::lib_3_1::alias_3_function as altalias_3_function;
+
+pub use ::lib_3_1::Alias3Trait as AltAlias3Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_4_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_4_1.sw
new file mode 100644
index 00000000000..49a2fd95803
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_4_1.sw
@@ -0,0 +1,12 @@
+library;
+
+pub use ::items_4::Items4_Struct as Alias4_Struct;
+
+pub use ::items_4::Items4_Enum as Alias4_Enum;
+
+pub use ::items_4::Items4_Variants::S as Alias4_S;
+pub use ::items_4::Items4_Variants::T as Alias4_T;
+
+pub use ::items_4::ITEMS_4_FUNCTION_RES as ALIAS_4_FUNCTION_RES;
+
+pub use ::items_4::items_4_function as alias_4_function;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_4_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_4_2.sw
new file mode 100644
index 00000000000..9ccad36059d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/lib_4_2.sw
@@ -0,0 +1,12 @@
+library;
+
+pub use ::items_4::Items4_Struct as AltAlias4_Struct;
+
+pub use ::items_4::Items4_Enum as AltAlias4_Enum;
+
+pub use ::items_4::Items4_Variants::S as AltAlias4_S;
+pub use ::items_4::Items4_Variants::T as AltAlias4_T;
+
+pub use ::items_4::ITEMS_4_FUNCTION_RES as ALTALIAS_4_FUNCTION_RES;
+
+pub use ::items_4::items_4_function as alt_alias_4_function;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/main.sw
new file mode 100755
index 00000000000..18a842fa725
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/main.sw
@@ -0,0 +1,18 @@
+script;
+
+mod items_1;
+mod lib_1;  // Aliased item reexports of items_1
+mod items_2;
+mod lib_2;  // Aliased item reexports of items_2
+mod items_3;
+mod lib_3_1;  // Aliased item reexports of items_3
+mod lib_3_2;  // Aliased item reexports of lib_3_1
+mod items_4;
+mod lib_4_1;  // Aliased item reexports of items_4
+mod lib_4_2;  // Aliased item reexports of items_4 with different aliases
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/tests.sw
new file mode 100644
index 00000000000..4e3b3e466b4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/src/tests.sw
@@ -0,0 +1,253 @@
+library;
+
+ // Reexported items from items_1.sw. All reexports aliased by lib_1
+use ::lib_1::Alias1_Struct;
+use ::lib_1::Alias1_Enum;
+use ::lib_1::Alias1_X;
+use ::lib_1::Alias1_Y;
+use ::lib_1::ALIAS_1_FUNCTION_RES;
+use ::lib_1::alias_1_function;
+use ::lib_1::Alias1Trait;
+
+use ::items_1::Items1_Variants;
+
+// Reexported items from items_2.sw. All reexports aliased by lib_2
+use ::lib_2::*;
+
+use ::items_2::Items2_Variants;
+
+// Reexported items from items_3.sw. All reexports aliased by lib_3_1 and then by lib_3_2
+use ::lib_3_2::*;
+
+use ::items_3::Items3_Variants;
+
+// Reexported items from items_4.sw. All items are reexported and aliased by lib_4_1 and by lib_4_2 using different aliases.
+use ::lib_4_1::*;
+use ::lib_4_2::*;
+
+use ::items_4::Items4_Variants;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Alias1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Alias1_Enum) -> u64 {
+    match input {
+	Alias1_Enum::A(val) => val,
+	Alias1_Enum::B(val) => val + 1000,
+    }
+}
+
+// Aliased enum variants are not recognized as belonging to the enum they're coming from,
+// so this test is disabled
+//fn project_items_1_variants(input: Items1_Variants) -> u64 {
+//    match input {
+//	Alias1_X(val) => val,
+//	Alias1_Y(val) => val + 1000,
+//    }
+//}
+
+fn call_items_1_function() -> u64 {
+    alias_1_function()
+}
+
+impl Alias1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Alias2_Struct) -> u64 {
+    input.b
+}
+
+fn project_items_2_enum(input: Alias2_Enum) -> u64 {
+    match input {
+	Alias2_Enum::C(val) => val,
+	Alias2_Enum::D(val) => val + 1000,
+    }
+}
+
+// Aliased enum variants are not recognized as belonging to the enum they're coming from,
+// so this test is disabled
+//fn project_items_2_variants(input: Items2_Variants) -> u64 {
+//    match input {
+//	Alias2_Z(val) => val,
+//	Alias2_W(val) => val + 1000,
+//    }
+//}
+
+fn call_items_2_function() -> u64 {
+    alias_2_function()
+}
+
+impl Alias2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_3 tests
+
+fn project_items_3_struct(input: AltAlias3_Struct) -> u64 {
+    input.c
+}
+
+fn project_items_3_enum(input: AltAlias3_Enum) -> u64 {
+    match input {
+	AltAlias3_Enum::E(val) => val,
+	AltAlias3_Enum::F(val) => val + 1000,
+    }
+}
+
+// Aliased enum variants are not recognized as belonging to the enum they're coming from,
+// so this test is disabled
+//fn project_items_3_variants(input: Items3_Variants) -> u64 {
+//    match input {
+//	AltAlias3_U(val) => val,
+//	AltAlias3_V(val) => val + 1000,
+//    }
+//}
+
+fn call_items_3_function() -> u64 {
+    altalias_3_function()
+}
+
+impl AltAlias3Trait<TestStruct2> for TestStruct1 {
+    fn items_3_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_4 tests
+
+fn project_items_4_struct(input: AltAlias4_Struct) -> u64 {
+    input.d
+}
+
+fn project_items_4_enum(input: Alias4_Enum) -> u64 {
+    match input {
+	Alias4_Enum::G(val) => val,
+	AltAlias4_Enum::H(val) => val + 1000,
+    }
+}
+
+// Aliased enum variants are not recognized as belonging to the enum they're coming from,
+// so this test is disabled
+//fn project_items_4_variants(input: Items4_Variants) -> u64 {
+//    match input {
+//	Alias4_S(val) => val,
+//	AltAlias4_T(val) => val + 1000,
+//    }
+//}
+
+fn call_items_4_function() -> u64 {
+    alias_4_function() + alt_alias_4_function()
+}
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Alias1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Alias1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+// Alias1_X is recognized as an alias, but it's still impossible to construct a value using Alias1_X
+//    let items_1_variants = Alias1_X(680);
+//    let items_1_variants_res = project_items_1_variants(items_1_variants);
+//    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ALIAS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Alias2_Struct { b: 123 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 123);
+
+    let items_2_enum = Alias2_Enum::C(432);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 432);
+
+    // Alias2_Z is recognized as an alias, but it's still impossible to construct a value using Alias2_Z
+//    let items_2_variants = Alias2_Z(680);
+//    let items_2_variants_res = project_items_2_variants(items_2_variants);
+//    assert(items_2_variants_res == 680);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ALIAS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+
+    let items_3_struct = AltAlias3_Struct { c: 123 };
+    let items_3_struct_res = project_items_3_struct(items_3_struct);
+    assert(items_3_struct_res == 123);
+
+    let items_3_enum = AltAlias3_Enum::E(432);
+    let items_3_enum_res = project_items_3_enum(items_3_enum);
+    assert(items_3_enum_res == 432);
+
+    // AltAlias3_U is recognized as an alias, but it's still impossible to construct a value using AltAlias3_U
+//    let items_3_variants = AltAlias3_U(680);
+//    let items_3_variants_res = project_items_3_variants(items_3_variants);
+//    assert(items_3_variants_res == 680);
+
+    let items_3_function_res = call_items_3_function();
+    assert(items_3_function_res == ALTALIAS_3_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+    assert(items_3_trait_teststruct_1_res);
+
+
+    let items_4_struct = AltAlias4_Struct { d: 123 };
+    let items_4_struct_res = project_items_4_struct(items_4_struct);
+    assert(items_4_struct_res == 123);
+
+    let items_4_enum = AltAlias4_Enum::G(432);
+    let items_4_enum_res = project_items_4_enum(items_4_enum);
+    assert(items_4_enum_res == 432);
+
+    // AltAlias4_S is recognized as an alias, but it's still impossible to construct a value using AltAlias4_S
+//    let items_4_variants = AltAlias4_S(680);
+//    let items_4_variants_res = project_items_4_variants(items_4_variants);
+//    assert(items_4_variants_res == 680);
+
+    let items_4_function_res = call_items_4_function();
+    assert(items_4_function_res == ALTALIAS_4_FUNCTION_RES * 2);
+
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/test.toml
old mode 100644
new mode 100755
similarity index 89%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/test.toml
index 057e34e97ef..5b7635b072b
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/aliases/test.toml
@@ -2,3 +2,4 @@ category = "run"
 expected_result = { action = "return", value = 42 }
 expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
 validate_abi = true
+expected_warnings = 7
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/Forc.lock
new file mode 100755
index 00000000000..d59e66c3300
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-5E33A7D67412F1BB"
+
+[[package]]
+name = "multiple_imports_of_same_reexport"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-5E33A7D67412F1BB"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/Forc.toml
new file mode 100755
index 00000000000..06785d8428a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "multiple_imports_of_same_reexport"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_2.sw
new file mode 100755
index 00000000000..1fa9465b0ec
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub enum Items2_Variants {
+    Z: u64,
+    W: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_3.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_3.sw
new file mode 100644
index 00000000000..40359c434ad
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_3.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items3_Struct {
+    pub c: u64,
+}
+
+pub enum Items3_Enum {
+    E: u64,
+    F: u64,
+}
+
+pub enum Items3_Variants {
+    U: u64,
+    V: u64,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 1111;
+
+pub fn items_3_function() -> u64 {
+    ITEMS_3_FUNCTION_RES
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_4.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_4.sw
new file mode 100644
index 00000000000..2d93dc802f4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/items_4.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: u64,
+}
+
+pub enum Items4_Enum {
+    G: u64,
+    H: u64,
+}
+
+pub enum Items4_Variants {
+    S: u64,
+    T: u64,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 5325;
+
+pub fn items_4_function() -> u64 {
+    ITEMS_4_FUNCTION_RES
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_1_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_1_1.sw
new file mode 100644
index 00000000000..37a603bf191
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_1_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct;
+
+pub use ::items_1::Items1_Enum;
+
+pub use ::items_1::Items1_Variants::X;
+pub use ::items_1::Items1_Variants::Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function;
+
+pub use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_1_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_1_2.sw
new file mode 100644
index 00000000000..37a603bf191
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_1_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct;
+
+pub use ::items_1::Items1_Enum;
+
+pub use ::items_1::Items1_Variants::X;
+pub use ::items_1::Items1_Variants::Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function;
+
+pub use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_2_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_2_1.sw
new file mode 100644
index 00000000000..8689296a943
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_2_1.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_2::*;
+
+pub use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_2_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_2_2.sw
new file mode 100644
index 00000000000..8689296a943
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_2_2.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_2::*;
+
+pub use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_3_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_3_1.sw
new file mode 100644
index 00000000000..b5955209281
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_3_1.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_3::*;
+
+pub use ::items_3::Items3_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_3_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_3_2.sw
new file mode 100644
index 00000000000..0bc3e96a689
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_3_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_3::Items3_Struct;
+
+pub use ::items_3::Items3_Enum;
+
+pub use ::items_3::Items3_Variants::U;
+pub use ::items_3::Items3_Variants::V;
+
+pub use ::items_3::ITEMS_3_FUNCTION_RES;
+
+pub use ::items_3::items_3_function;
+
+pub use ::items_3::Items3Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_4_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_4_1.sw
new file mode 100644
index 00000000000..2c2c70401b6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_4_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_4::Items4_Struct;
+
+pub use ::items_4::Items4_Enum;
+
+pub use ::items_4::Items4_Variants::S;
+pub use ::items_4::Items4_Variants::T;
+
+pub use ::items_4::ITEMS_4_FUNCTION_RES;
+
+pub use ::items_4::items_4_function;
+
+pub use ::items_4::Items4Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_4_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_4_2.sw
new file mode 100644
index 00000000000..ba688f2f755
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/lib_4_2.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_4::*;
+
+pub use ::items_4::Items4_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/main.sw
new file mode 100755
index 00000000000..4ae46fbab15
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/main.sw
@@ -0,0 +1,20 @@
+script;
+
+mod items_1;
+mod lib_1_1;  // Item reexports of items_1
+mod lib_1_2;  // Item reexports of items_1
+mod items_2;
+mod lib_2_1;  // Star reexports of items_2
+mod lib_2_2;  // Star reexports of items_2
+mod items_3;
+mod lib_3_1;  // Star reexports of items_3
+mod lib_3_2;  // Item reexports of items_3
+mod items_4;
+mod lib_4_1;  // Item reexports of items_4
+mod lib_4_2;  // Star reexports of items_4
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/tests.sw
new file mode 100644
index 00000000000..c1058c32671
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/src/tests.sw
@@ -0,0 +1,243 @@
+library;
+
+// Both lib_1_1.sw and lib_1_2.sw reexport items from items_1.sw. All reexports are item imports.
+// Importing both lib_1_1 and lib_1_2 should not cause a name clash.
+use ::lib_1_1::*; 
+use ::lib_1_2::*;
+// Both lib_2_1.sw and lib_2_2.sw reexport items from items_2.sw. All reexports are star imports.
+// Importing both lib_2_1 and lib_2_2 should not cause a name clash.
+use ::lib_2_1::*; 
+use ::lib_2_2::*;
+// Both lib_3_1.sw and lib_3_2.sw reexport items from items_3.sw. lib_3_1 star reexports, lib_3_2
+// item reexports. Importing both lib_3_1 and lib_3_2 should not cause a name clash.
+use ::lib_3_1::*;
+use ::lib_3_2::*;
+// Both lib_4_1.sw and lib_4_2.sw reexport items from items_4.sw. lib_4_1 item reexports, lib_4_2
+// star reexports. Importing both lib_4_1 and lib_4_2 should not cause a name clash.
+// This tests that ordering of imports do not matter.
+use ::lib_4_1::*;
+use ::lib_4_2::*;
+
+use ::items_1::Items1_Variants;
+use ::items_2::Items2_Variants;
+use ::items_3::Items3_Variants;
+use ::items_4::Items4_Variants;
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+// items_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+// items_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.b
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::C(val) => val,
+	Items2_Enum::D(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	Z(val) => val,
+	W(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+   fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+   }
+}
+
+// items_3 tests
+
+fn project_items_3_struct(input: Items3_Struct) -> u64 {
+    input.c
+}
+
+fn project_items_3_enum(input: Items3_Enum) -> u64 {
+    match input {
+	Items3_Enum::E(val) => val,
+	Items3_Enum::F(val) => val + 1000,
+    }
+}
+
+fn project_items_3_variants(input: Items3_Variants) -> u64 {
+    match input {
+	U(val) => val,
+	V(val) => val + 1000,
+    }
+}
+
+fn call_items_3_function() -> u64 {
+    items_3_function()
+}
+
+impl Items3Trait<TestStruct2> for TestStruct1 {
+    fn items_3_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 122 && x.W
+    }
+}
+
+// items_4 tests
+
+fn project_items_4_struct(input: Items4_Struct) -> u64 {
+    input.d
+}
+
+fn project_items_4_enum(input: Items4_Enum) -> u64 {
+    match input {
+	Items4_Enum::G(val) => val,
+	Items4_Enum::H(val) => val + 1000,
+    }
+}
+
+fn project_items_4_variants(input: Items4_Variants) -> u64 {
+    match input {
+	S(val) => val,
+	T(val) => val + 1000,
+    }
+}
+
+fn call_items_4_function() -> u64 {
+    items_4_function()
+}
+
+impl Items4Trait<TestStruct2> for TestStruct1 {
+    fn items_4_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 122 && x.W
+    }
+}
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+ 
+    let items_2_struct = Items2_Struct { b: 789 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 789);
+ 
+    let items_2_enum = Items2_Enum::C(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+ 
+    let items_2_variants = Z(468);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 468);
+ 
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+ 
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+
+    let items_3_struct = Items3_Struct { c: 789 };
+    let items_3_struct_res = project_items_3_struct(items_3_struct);
+    assert(items_3_struct_res == 789);
+ 
+    let items_3_enum = Items3_Enum::E(246);
+    let items_3_enum_res = project_items_3_enum(items_3_enum);
+    assert(items_3_enum_res == 246);
+ 
+    let items_3_variants = U(468);
+    let items_3_variants_res = project_items_3_variants(items_3_variants);
+    assert(items_3_variants_res == 468);
+ 
+    let items_3_function_res = call_items_3_function();
+    assert(items_3_function_res == ITEMS_3_FUNCTION_RES);
+ 
+    let teststruct_1 = TestStruct1 { Z : 122 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+    assert(items_3_trait_teststruct_1_res);
+
+
+    let items_4_struct = Items4_Struct { d: 789 };
+    let items_4_struct_res = project_items_4_struct(items_4_struct);
+    assert(items_4_struct_res == 789);
+ 
+    let items_4_enum = Items4_Enum::G(246);
+    let items_4_enum_res = project_items_4_enum(items_4_enum);
+    assert(items_4_enum_res == 246);
+ 
+    let items_4_variants = S(468);
+    let items_4_variants_res = project_items_4_variants(items_4_variants);
+    assert(items_4_variants_res == 468);
+ 
+    let items_4_function_res = call_items_4_function();
+    assert(items_4_function_res == ITEMS_4_FUNCTION_RES);
+ 
+    let teststruct_1 = TestStruct1 { Z : 122 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_4_trait_teststruct_1_res = teststruct_1.items_4_trait_function(teststruct_2);
+    assert(items_4_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/test.toml
old mode 100644
new mode 100755
similarity index 79%
rename from test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/test.toml
index fd4c98366b9..0b73866a32b
--- a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/multiple_imports_of_same_reexport/test.toml
@@ -1,4 +1,5 @@
 category = "run"
 expected_result = { action = "return", value = 42 }
 expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
-supported_targets = ["midenvm"]
+validate_abi = true
+expected_warnings = 1
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/Forc.lock
new file mode 100755
index 00000000000..5238fc6cfc4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-CE974A175C1B7D31"
+
+[[package]]
+name = "reexport_paths"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-CE974A175C1B7D31"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/Forc.toml
new file mode 100755
index 00000000000..5d787dce6ac
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "reexport_paths"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_1_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_1_1.sw
new file mode 100644
index 00000000000..9d3a4594442
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_1_1.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ::items_1::*;
+pub use ::items_1::Items1_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_1_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_1_2.sw
new file mode 100644
index 00000000000..a1de8f9d9de
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_1_2.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ::lib_1_1::*;
+pub use ::lib_1_1::Items1_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_2.sw
new file mode 100644
index 00000000000..a298d9f1943
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_2.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use std::hash::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_3_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_3_1.sw
new file mode 100644
index 00000000000..e6bfbe13e7b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_3_1.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use std::ecr::EcRecoverError;
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_3_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_3_2.sw
new file mode 100644
index 00000000000..00d14947ef8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_3_2.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use std::ecr::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_4.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_4.sw
new file mode 100644
index 00000000000..462edd378e7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_4.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use std::registers::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_5.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_5.sw
new file mode 100644
index 00000000000..b5031e1af4e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_5.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use core::codec::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_6_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_6_1.sw
new file mode 100644
index 00000000000..41f4c8609f4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_6_1.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use std::prelude::Address;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_6_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_6_2.sw
new file mode 100644
index 00000000000..69dc48f1dd2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/lib_6_2.sw
@@ -0,0 +1,3 @@
+library;
+
+pub use std::address::Address;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/main.sw
new file mode 100755
index 00000000000..84a4dffa3df
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/main.sw
@@ -0,0 +1,18 @@
+script;
+
+mod items_1;
+mod lib_1_1;  // Reexports of items_1
+mod lib_1_2;  // Reexports of lib_1_1
+mod lib_2;  // Reexports of std::hash::Hasher, which is not part of the std prelude
+mod lib_3_1;  // Reexports of std::hash::Hash, which is not part of the std prelude
+mod lib_3_2;  // Reexports of std::hash::Hash, which is not part of the std prelude
+mod lib_4;  // Reexport of std::registers::global_gas
+mod lib_5;  // Reexport of core::codec::*
+//mod lib_6_1;  // Reexports of std::address::Address from the std prelude
+mod lib_6_2;  // Reexports of std::address::Address directly from std::address
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/tests.sw
new file mode 100644
index 00000000000..453221c03ba
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/src/tests.sw
@@ -0,0 +1,140 @@
+library;
+
+// Items from items_1.sw reexported via lib_1_1 and lib_1_2.
+use ::lib_1_2::*;
+// Reexport of std::hash::*, which is not part of the std prelude.
+use ::lib_2::*;
+// Reexports of std::ecr::EcRecoverError, which is not part of the std prelude.
+use ::lib_3_1::*;
+use ::lib_3_2::*;
+// Reexport of std::registers::*, which is not part of the std prelude.
+use ::lib_4::global_gas;
+// Reexport of core::codec::*, which is part of the std prelude.
+use ::lib_5::Buffer;
+// Reexports of std::address::Address, one via std::prelude and one directly from std::address
+// Importing from std::prelude causes an error, so that part of the test is disabled for now.
+//use ::lib_6_1::*;
+use ::lib_6_2::*;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn mk_hasher() -> Hasher {
+    Hasher::new()
+}
+
+impl Hash for TestStruct1 {
+    fn hash(self, ref mut _state: Hasher) {
+    }
+}
+
+
+// lib_3 tests
+
+fn mk_ec_recover_error() -> EcRecoverError {
+    EcRecoverError::UnrecoverablePublicKey
+}
+
+
+// lib_4 tests
+
+fn get_global_gas() -> u64 {
+    global_gas()
+}
+
+
+// lib_5 tests
+
+fn mk_buffer() -> Buffer {
+    Buffer::new()
+}
+
+
+// lib_6 tests
+
+fn mk_address() -> Address {
+    Address::zero()
+}
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let hasher = mk_hasher();
+    teststruct_1.hash(hasher);
+
+
+    let _ = mk_ec_recover_error();
+
+
+    let _ = get_global_gas();
+
+
+    let _ = mk_buffer();
+
+
+    let _ = mk_address();
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/test.toml
new file mode 100755
index 00000000000..5341fe8486c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths/test.toml
@@ -0,0 +1,5 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
+validate_abi = true
+expected_warnings = 0
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/Forc.lock
new file mode 100644
index 00000000000..72fcfaba5ec
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/Forc.lock
@@ -0,0 +1,76 @@
+[[package]]
+name = "core"
+source = "path+from-root-43D7B7046829C73F"
+
+[[package]]
+name = "ext_1_items"
+source = "member"
+
+[[package]]
+name = "ext_1_lib"
+source = "member"
+dependencies = ["ext_1_items"]
+
+[[package]]
+name = "ext_2_items"
+source = "member"
+
+[[package]]
+name = "ext_2_lib"
+source = "member"
+dependencies = ["ext_2_items"]
+
+[[package]]
+name = "ext_3_items"
+source = "member"
+
+[[package]]
+name = "ext_3_lib"
+source = "member"
+dependencies = ["ext_3_items"]
+
+[[package]]
+name = "ext_4_items"
+source = "member"
+
+[[package]]
+name = "ext_4_lib"
+source = "member"
+dependencies = ["ext_4_items"]
+
+[[package]]
+name = "ext_5_1_lib"
+source = "member"
+dependencies = ["ext_5_items"]
+
+[[package]]
+name = "ext_5_2_lib"
+source = "member"
+dependencies = ["ext_5_items"]
+
+[[package]]
+name = "ext_5_items"
+source = "member"
+
+[[package]]
+name = "program"
+source = "member"
+dependencies = [
+    "ext_1_items",
+    "ext_1_lib",
+    "ext_2_items",
+    "ext_2_lib",
+    "ext_3_items",
+    "ext_3_lib",
+    "ext_4_items",
+    "ext_4_lib",
+    "ext_5_1_lib",
+    "ext_5_2_lib",
+    "ext_5_items",
+    "std",
+]
+
+[[package]]
+name = "std"
+source = "path+from-root-43D7B7046829C73F"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/Forc.toml
new file mode 100644
index 00000000000..6bb836d1178
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/Forc.toml
@@ -0,0 +1,14 @@
+[workspace]
+members = ["program",
+	   "ext_1_items",
+	   "ext_1_lib",
+	   "ext_2_items",
+	   "ext_2_lib",
+	   "ext_3_items",
+	   "ext_3_lib",
+	   "ext_4_items",
+	   "ext_4_lib",
+	   "ext_5_items",
+	   "ext_5_1_lib",
+	   "ext_5_2_lib",
+	   ] 
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_items/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_items/Forc.toml
new file mode 100644
index 00000000000..12da0871200
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_items/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_1_items"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_items/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_items/src/lib.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_items/src/lib.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_lib/Forc.toml
new file mode 100644
index 00000000000..2230a157aad
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_lib/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_1_lib"
+implicit-std = false
+
+[dependencies]
+ext_1_items = { path = "../ext_1_items/" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_lib/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_lib/src/lib.sw
new file mode 100644
index 00000000000..152e4e004b3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_1_lib/src/lib.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ext_1_items::Items1_Struct;
+
+pub use ext_1_items::Items1_Enum;
+
+pub use ext_1_items::Items1_Variants::X;
+pub use ext_1_items::Items1_Variants::Y;
+
+pub use ext_1_items::ITEMS_1_FUNCTION_RES;
+
+pub use ext_1_items::items_1_function;
+
+pub use ext_1_items::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_items/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_items/Forc.toml
new file mode 100644
index 00000000000..fb9c571f29e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_items/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_2_items"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_items/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_items/src/lib.sw
new file mode 100644
index 00000000000..3802e175e76
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_items/src/lib.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub enum Items2_Variants {
+    Z: u64,
+    W: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 324;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_lib/Forc.toml
new file mode 100644
index 00000000000..711c4baf383
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_lib/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_2_lib"
+implicit-std = false
+
+[dependencies]
+ext_2_items = { path = "../ext_2_items/" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_lib/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_lib/src/lib.sw
new file mode 100644
index 00000000000..4f7c5f4d30d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_2_lib/src/lib.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ext_2_items::*;
+pub use ext_2_items::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_items/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_items/Forc.toml
new file mode 100644
index 00000000000..a04f49ceead
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_items/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_3_items"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_items/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_items/src/lib.sw
new file mode 100644
index 00000000000..4d61d81be80
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_items/src/lib.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items3_Struct {
+    pub c: u64,
+}
+
+pub enum Items3_Enum {
+    E: u64,
+    F: u64,
+}
+
+pub enum Items3_Variants {
+    U: u64,
+    V: u64,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 893;
+
+pub fn items_3_function() -> u64 {
+    ITEMS_3_FUNCTION_RES
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_lib/Forc.toml
new file mode 100644
index 00000000000..56967137a18
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_lib/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_3_lib"
+implicit-std = false
+
+[dependencies]
+ext_3_items = { path = "../ext_3_items/" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_lib/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_lib/src/lib.sw
new file mode 100644
index 00000000000..79e79fb09d5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_3_lib/src/lib.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ext_3_items::Items3_Struct;
+
+pub use ext_3_items::Items3_Enum;
+
+pub use ext_3_items::Items3_Variants::U;
+pub use ext_3_items::Items3_Variants::V;
+
+pub use ext_3_items::ITEMS_3_FUNCTION_RES;
+
+pub use ext_3_items::items_3_function;
+
+pub use ext_3_items::Items3Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_items/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_items/Forc.toml
new file mode 100644
index 00000000000..555024e8f6c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_items/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_4_items"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_items/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_items/src/lib.sw
new file mode 100644
index 00000000000..740942a391a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_items/src/lib.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: u64,
+}
+
+pub enum Items4_Enum {
+    G: u64,
+    H: u64,
+}
+
+pub enum Items4_Variants {
+    S: u64,
+    T: u64,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 2389;
+
+pub fn items_4_function() -> u64 {
+    ITEMS_4_FUNCTION_RES
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_lib/Forc.toml
new file mode 100644
index 00000000000..bbb8b468d40
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_lib/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_4_lib"
+implicit-std = false
+
+[dependencies]
+ext_4_items = { path = "../ext_4_items/" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_lib/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_lib/src/lib.sw
new file mode 100644
index 00000000000..8084e777a58
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_4_lib/src/lib.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ext_4_items::*;
+pub use ext_4_items::Items4_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_1_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_1_lib/Forc.toml
new file mode 100644
index 00000000000..db6f8a3fdf8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_1_lib/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_5_1_lib"
+implicit-std = false
+
+[dependencies]
+ext_5_items = { path = "../ext_5_items/" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_1_lib/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_1_lib/src/lib.sw
new file mode 100644
index 00000000000..eafc9dea600
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_1_lib/src/lib.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ext_5_items::*;
+pub use ext_5_items::Items5_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_2_lib/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_2_lib/Forc.toml
new file mode 100644
index 00000000000..03e87b6ca67
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_2_lib/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_5_2_lib"
+implicit-std = false
+
+[dependencies]
+ext_5_items = { path = "../ext_5_items/" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_2_lib/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_2_lib/src/lib.sw
new file mode 100644
index 00000000000..eafc9dea600
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_2_lib/src/lib.sw
@@ -0,0 +1,4 @@
+library;
+
+pub use ext_5_items::*;
+pub use ext_5_items::Items5_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_items/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_items/Forc.toml
new file mode 100644
index 00000000000..403f3fb061e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_items/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "ext_5_items"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_items/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_items/src/lib.sw
new file mode 100644
index 00000000000..b8bd79e4559
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/ext_5_items/src/lib.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items5_Struct {
+    pub e: u64,
+}
+
+pub enum Items5_Enum {
+    I: u64,
+    J: u64,
+}
+
+pub enum Items5_Variants {
+    Q: u64,
+    R: u64,
+}
+
+pub const ITEMS_5_FUNCTION_RES = 32894;
+
+pub fn items_5_function() -> u64 {
+    ITEMS_5_FUNCTION_RES
+}
+
+pub trait Items5Trait<T> {
+    fn items_5_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/json_abi_oracle_new_encoding.json
new file mode 100755
index 00000000000..068da3305ab
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/json_abi_oracle_new_encoding.json
@@ -0,0 +1,26 @@
+{
+  "configurables": [],
+  "encoding": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/Forc.toml
new file mode 100755
index 00000000000..56fc83c4f7d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/Forc.toml
@@ -0,0 +1,20 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "program"
+implicit-std = false
+
+[dependencies]
+ext_1_items = { path = "../ext_1_items/" }
+ext_1_lib = { path = "../ext_1_lib/" }
+ext_2_items = { path = "../ext_2_items/" }
+ext_2_lib = { path = "../ext_2_lib/" }
+ext_3_items = { path = "../ext_3_items/" }
+ext_3_lib = { path = "../ext_3_lib/" }
+ext_4_items = { path = "../ext_4_items/" }
+ext_4_lib = { path = "../ext_4_lib/" }
+ext_5_items = { path = "../ext_5_items/" }
+ext_5_1_lib = { path = "../ext_5_1_lib/" }
+ext_5_2_lib = { path = "../ext_5_2_lib/" }
+std = { path = "../../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/src/main.sw
new file mode 100755
index 00000000000..bcc453959df
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/src/main.sw
@@ -0,0 +1,7 @@
+script;
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/src/tests.sw
new file mode 100644
index 00000000000..5670d3deaa3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/program/src/tests.sw
@@ -0,0 +1,310 @@
+library;
+
+// Reexported items from ext_1_items. All reexports are item imports.
+use ext_1_lib::*;
+use ext_1_items::Items1_Variants;
+// Reexported items from ext_2_items. All reexports are star imports.
+use ext_2_lib::*;
+// Reexported items from ext_3_items. All reexports are item imports.
+use ext_3_lib::Items3_Struct;
+use ext_3_lib::Items3_Enum;
+// ext_3_lib elevates U and V to the same namespace as the type names, so Items3_Variants cannot be found in ext_3_lib.
+//use ext_3_lib::Items3_Variants::U;
+//use ext_3_lib::Items3_Variants::V;
+use ext_3_lib::U;
+use ext_3_lib::V;
+use ext_3_lib::ITEMS_3_FUNCTION_RES;
+use ext_3_lib::items_3_function;
+use ext_3_lib::Items3Trait;
+use ext_3_items::Items3_Variants;
+// Reexported items from ext_4_items. All reexports are star imports.
+use ext_4_lib::Items4_Struct;
+use ext_4_lib::Items4_Enum;
+// ext_4_lib elevates S and T to the same namespace as the type names, so Items4_Variants cannot be found in ext_4_lib.
+//use ext_4_lib::Items4_Variants::S;
+//use ext_4_lib::Items4_Variants::T;
+use ext_4_lib::S;
+use ext_4_lib::T;
+use ext_4_lib::ITEMS_4_FUNCTION_RES;
+use ext_4_lib::items_4_function;
+use ext_4_lib::Items4Trait;
+use ext_4_items::Items4_Variants;
+// Reexported items from ext_5_items through two libraries.
+use ext_5_1_lib::*;
+use ext_5_2_lib::*;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// ext_1_lib tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// ext_2_lib tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.b
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::C(val) => val,
+	Items2_Enum::D(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	Z(val) => val,
+	W(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// ext_3_lib tests
+
+fn project_items_3_struct(input: Items3_Struct) -> u64 {
+    input.c
+}
+
+fn project_items_3_enum(input: Items3_Enum) -> u64 {
+    match input {
+	Items3_Enum::E(val) => val,
+	Items3_Enum::F(val) => val + 1000,
+    }
+}
+
+fn project_items_3_variants(input: Items3_Variants) -> u64 {
+    match input {
+	U(val) => val,
+	V(val) => val + 1000,
+    }
+}
+
+fn call_items_3_function() -> u64 {
+    items_3_function()
+}
+
+impl Items3Trait<TestStruct2> for TestStruct1 {
+    fn items_3_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// ext_4_lib tests
+
+fn project_items_4_struct(input: Items4_Struct) -> u64 {
+    input.d
+}
+
+fn project_items_4_enum(input: Items4_Enum) -> u64 {
+    match input {
+	Items4_Enum::G(val) => val,
+	Items4_Enum::H(val) => val + 1000,
+    }
+}
+
+fn project_items_4_variants(input: Items4_Variants) -> u64 {
+    match input {
+	S(val) => val,
+	T(val) => val + 1000,
+    }
+}
+
+fn call_items_4_function() -> u64 {
+    items_4_function()
+}
+
+impl Items4Trait<TestStruct2> for TestStruct1 {
+    fn items_4_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// ext_5_lib tests
+
+fn project_items_5_struct(input: Items5_Struct) -> u64 {
+    input.e
+}
+
+fn project_items_5_enum(input: Items5_Enum) -> u64 {
+    match input {
+	Items5_Enum::I(val) => val,
+	Items5_Enum::J(val) => val + 1000,
+    }
+}
+
+fn project_items_5_variants(input: Items5_Variants) -> u64 {
+    match input {
+	Q(val) => val,
+	R(val) => val + 1000,
+    }
+}
+
+fn call_items_5_function() -> u64 {
+    items_5_function()
+}
+
+impl Items5Trait<TestStruct2> for TestStruct1 {
+    fn items_5_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Items2_Struct { b: 223 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 223);
+
+    let items_2_enum = Items2_Enum::C(432);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 432);
+
+    let items_2_variants = Z(680);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 680);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+
+    let items_3_struct = Items3_Struct { c: 323 };
+    let items_3_struct_res = project_items_3_struct(items_3_struct);
+    assert(items_3_struct_res == 323);
+
+    let items_3_enum = Items3_Enum::E(432);
+    let items_3_enum_res = project_items_3_enum(items_3_enum);
+    assert(items_3_enum_res == 432);
+
+    let items_3_variants = U(680);
+    let items_3_variants_res = project_items_3_variants(items_3_variants);
+    assert(items_3_variants_res == 680);
+
+    let items_3_function_res = call_items_3_function();
+    assert(items_3_function_res == ITEMS_3_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+    assert(items_3_trait_teststruct_1_res);
+
+
+    let items_4_struct = Items4_Struct { d: 424 };
+    let items_4_struct_res = project_items_4_struct(items_4_struct);
+    assert(items_4_struct_res == 424);
+
+    let items_4_enum = Items4_Enum::G(442);
+    let items_4_enum_res = project_items_4_enum(items_4_enum);
+    assert(items_4_enum_res == 442);
+
+    let items_4_variants = S(680);
+    let items_4_variants_res = project_items_4_variants(items_4_variants);
+    assert(items_4_variants_res == 680);
+
+    let items_4_function_res = call_items_4_function();
+    assert(items_4_function_res == ITEMS_4_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_4_trait_teststruct_1_res = teststruct_1.items_4_trait_function(teststruct_2);
+    assert(items_4_trait_teststruct_1_res);
+
+
+    let items_5_struct = Items5_Struct { e: 525 };
+    let items_5_struct_res = project_items_5_struct(items_5_struct);
+    assert(items_5_struct_res == 525);
+
+    let items_5_enum = Items5_Enum::I(552);
+    let items_5_enum_res = project_items_5_enum(items_5_enum);
+    assert(items_5_enum_res == 552);
+
+    let items_5_variants = Q(680);
+    let items_5_variants_res = project_items_5_variants(items_5_variants);
+    assert(items_5_variants_res == 680);
+
+    let items_5_function_res = call_items_5_function();
+    assert(items_5_function_res == ITEMS_5_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_5_trait_teststruct_1_res = teststruct_1.items_5_trait_function(teststruct_2);
+    assert(items_5_trait_teststruct_1_res);
+
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/test.toml
new file mode 100644
index 00000000000..2c5bf1ae09a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/reexport_paths_external_lib/test.toml
@@ -0,0 +1,2 @@
+category = "compile"
+expected_warnings = 0
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/Forc.lock
new file mode 100755
index 00000000000..ac25cb26c8e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-EE202EE2D1735C08"
+
+[[package]]
+name = "shadowing_in_reexporting_module"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-EE202EE2D1735C08"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/Forc.toml
new file mode 100755
index 00000000000..4b87dd678a8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "shadowing_in_reexporting_module"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_1.sw
new file mode 100644
index 00000000000..95b236919b7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_1.sw
@@ -0,0 +1,20 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: bool,
+}
+
+pub enum Items1_Enum {
+    A: bool,
+    B: bool,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> bool {
+    ITEMS_1_FUNCTION_RES == 456
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_2_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_2_1.sw
new file mode 100644
index 00000000000..f00aa5f00c7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_2_1.sw
@@ -0,0 +1,20 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: bool,
+}
+
+pub enum Items2_Enum {
+    C: bool,
+    D: bool,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 789;
+
+pub fn items_2_function() -> bool {
+    ITEMS_2_FUNCTION_RES == 789
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_2_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_2_2.sw
new file mode 100644
index 00000000000..6822e86d865
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_2_2.sw
@@ -0,0 +1,20 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_3_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_3_1.sw
new file mode 100644
index 00000000000..86138d9e3ed
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_3_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items3_Struct {
+    pub c: bool,
+}
+
+pub enum Items3_Enum {
+    E: bool,
+    F: bool,
+}
+
+pub enum Items3_Variants {
+    G: bool,
+    H: bool,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 1234;
+
+pub fn items_3_function() -> bool {
+    ITEMS_3_FUNCTION_RES == 1234
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_1.sw
new file mode 100644
index 00000000000..2d9be57fc13
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: bool,
+}
+
+pub enum Items4_Enum {
+    I: bool,
+    J: bool,
+}
+
+pub enum Items4_Variants {
+    K: bool,
+    L: bool,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 5678;
+
+pub fn items_4_function() -> bool {
+    ITEMS_4_FUNCTION_RES == 5678
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_2.sw
new file mode 100644
index 00000000000..d57d5b3fbc6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items4_Struct {
+    pub d: u64,
+}
+
+pub enum Items4_Enum {
+    I: u64,
+    J: u64,
+}
+
+pub enum Items4_Variants {
+    K: u64,
+    L: u64,
+}
+
+pub const ITEMS_4_FUNCTION_RES = 8765;
+
+pub fn items_4_function() -> u64 {
+    ITEMS_4_FUNCTION_RES
+}
+
+pub trait Items4Trait<T> {
+    fn items_4_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_3.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_3.sw
new file mode 100644
index 00000000000..92293307319
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_3.sw
@@ -0,0 +1,6 @@
+library;
+
+pub enum Items4_Variants2 {
+    M: bool,
+    N: bool,
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_4.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_4.sw
new file mode 100644
index 00000000000..2f9d86748af
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/items_4_4.sw
@@ -0,0 +1,6 @@
+library;
+
+pub enum Items4_Variants2 {
+    M: u64,
+    N: u64,
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_1.sw
new file mode 100644
index 00000000000..642395e6bf1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_1.sw
@@ -0,0 +1,22 @@
+library;
+
+pub use ::items_1::*;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 654;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_2.sw
new file mode 100644
index 00000000000..44b21ced5ff
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_2.sw
@@ -0,0 +1,9 @@
+library;
+
+pub use ::items_2_1::*;
+
+pub use ::items_2_2::Items2_Struct;
+pub use ::items_2_2::Items2_Enum;
+pub use ::items_2_2::ITEMS_2_FUNCTION_RES;
+pub use ::items_2_2::items_2_function;
+pub use ::items_2_2::Items2Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_3.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_3.sw
new file mode 100644
index 00000000000..04f9a81605f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_3.sw
@@ -0,0 +1,28 @@
+library;
+
+pub use ::items_3_1::*;
+pub use ::items_3_1::Items3_Variants::*;
+
+pub struct Items3_Struct {
+    pub c: u64,
+}
+
+pub enum Items3_Enum {
+    E: u64,
+    F: u64,
+}
+
+pub enum Items3_Variants {
+    G: u64,
+    H: u64,
+}
+
+pub const ITEMS_3_FUNCTION_RES = 4321;
+
+pub fn items_3_function() -> u64 {
+    ITEMS_3_FUNCTION_RES
+}
+
+pub trait Items3Trait<T> {
+    fn items_3_trait_function(self, x: T) -> u64;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_4.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_4.sw
new file mode 100644
index 00000000000..fa17194cde9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/lib_4.sw
@@ -0,0 +1,17 @@
+library;
+
+pub use ::items_4_1::*;
+pub use ::items_4_1::Items4_Variants::*;
+
+pub use ::items_4_2::Items4_Struct;
+pub use ::items_4_2::Items4_Enum;
+pub use ::items_4_2::Items4_Variants;
+pub use ::items_4_2::Items4_Variants::K;
+pub use ::items_4_2::Items4_Variants::L;
+pub use ::items_4_2::ITEMS_4_FUNCTION_RES;
+pub use ::items_4_2::items_4_function;
+pub use ::items_4_2::Items4Trait;
+
+pub use ::items_4_3::Items4_Variants2::*;
+pub use ::items_4_4::Items4_Variants2::M;
+pub use ::items_4_4::Items4_Variants2::N;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/main.sw
new file mode 100755
index 00000000000..a2961173628
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/main.sw
@@ -0,0 +1,20 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2_1;
+mod items_2_2;
+mod lib_2;  // Item reexports of items_2_1 and items_2_2
+mod items_3_1;
+mod lib_3;  // Item reexports of items_3_1 and items_3_2
+mod items_4_1;
+mod items_4_2;
+mod items_4_3;
+mod items_4_4;
+mod lib_4;  // Item reexports of items_4_1 and items_4_2
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/tests.sw
new file mode 100644
index 00000000000..24e8370818e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/src/tests.sw
@@ -0,0 +1,262 @@
+library;
+
+// Reexported items from items_1.sw. All reexports shadowed by local definitions in lib_1.sw.
+use ::lib_1::*;
+ // Reexported items from items_2_1.sw and items_2_2.sw. All reexports from items_2_1.sw are
+ // shadowed by items imported from items_2_2.sw
+use ::lib_2::*;
+// Reexported items from items_3_1.sw and items_3_2.sw. All reexports shadowed by local definitions in lib_3.sw.
+use ::lib_3::Items3_Struct;
+use ::lib_3::Items3_Enum;
+use ::lib_3::Items3_Variants;
+use ::lib_3::Items3_Variants::G;
+use ::lib_3::Items3_Variants::H;
+use ::lib_3::ITEMS_3_FUNCTION_RES;
+use ::lib_3::items_3_function;
+use ::lib_3::Items3Trait;
+// Reexported items from items_4_1.sw and items_4_2.sw. All reexports from items_4_1.sw are
+// shadowed by items imported from items_4_2.sw
+use ::lib_4::Items4_Struct;
+use ::lib_4::Items4_Enum;
+use ::lib_4::Items4_Variants;
+use ::lib_4::Items4_Variants::K;
+use ::lib_4::Items4_Variants::L;
+use ::lib_4::ITEMS_4_FUNCTION_RES;
+use ::lib_4::items_4_function;
+use ::lib_4::Items4Trait;
+// Items4_Variants2 defined in items_4_4.sw, variants reexported by lib_4.sw
+use ::items_4_4::Items4_Variants2;
+use ::lib_4::M;
+use ::lib_4::N;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    self.Z
+	}
+	else {
+	    0
+	}
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.b
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::C(val) => val,
+	Items2_Enum::D(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    0
+	}
+	else {
+	    self.Z
+	}
+    }
+}
+
+
+// lib_3 tests
+
+fn project_items_3_struct(input: Items3_Struct) -> u64 {
+    input.c
+}
+
+fn project_items_3_enum(input: Items3_Enum) -> u64 {
+    match input {
+	Items3_Enum::E(val) => val,
+	Items3_Enum::F(val) => val + 1000,
+    }
+}
+
+fn project_items_3_variants(input: Items3_Variants) -> u64 {
+    match input {
+	Items3_Variants::G(val) => val,
+	Items3_Variants::H(val) => val + 1000,
+    }
+}
+
+fn call_items_3_function() -> u64 {
+    items_3_function()
+}
+
+impl Items3Trait<TestStruct2> for TestStruct1 {
+    fn items_3_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    self.Z
+	}
+	else {
+	    0
+	}
+    }
+}
+
+// lib_4 tests
+
+fn project_items_4_struct(input: Items4_Struct) -> u64 {
+    input.d
+}
+
+fn project_items_4_enum(input: Items4_Enum) -> u64 {
+    match input {
+	Items4_Enum::I(val) => val,
+	Items4_Enum::J(val) => val + 1000,
+    }
+}
+
+fn project_items_4_variants(input: Items4_Variants) -> u64 {
+    match input {
+	K(val) => val,
+	L(val) => val + 1000,
+    }
+}
+
+fn call_items_4_function() -> u64 {
+    items_4_function()
+}
+
+impl Items4Trait<TestStruct2> for TestStruct1 {
+    fn items_4_trait_function(self, x: TestStruct2) -> u64 {
+	if x.W {
+	    0
+	}
+	else {
+	    self.Z
+	}
+    }
+}
+
+fn project_items_4_variants2(input: Items4_Variants2) -> u64 {
+    match input {
+	M(val) => val,
+	N(val) => val + 1000,
+    }
+}
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res == 64);
+
+
+    let items_2_struct = Items2_Struct { b: 879 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 879);
+
+    let items_2_enum = Items2_Enum::C(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res == 128);
+
+
+    let items_3_struct = Items3_Struct { c: 123 };
+    let items_3_struct_res = project_items_3_struct(items_3_struct);
+    assert(items_3_struct_res == 123);
+
+    let items_3_enum = Items3_Enum::E(432);
+    let items_3_enum_res = project_items_3_enum(items_3_enum);
+    assert(items_3_enum_res == 432);
+
+    let items_3_variants = G(432);
+    let items_3_variants_res = project_items_3_variants(items_3_variants);
+    assert(items_3_variants_res == 432);
+
+    let items_3_function_res = call_items_3_function();
+    assert(items_3_function_res == ITEMS_3_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_3_trait_teststruct_1_res = teststruct_1.items_3_trait_function(teststruct_2);
+    assert(items_3_trait_teststruct_1_res == 64);
+
+    
+    let items_4_struct = Items4_Struct { d: 879 };
+    let items_4_struct_res = project_items_4_struct(items_4_struct);
+    assert(items_4_struct_res == 879);
+
+    let items_4_enum = Items4_Enum::I(446);
+    let items_4_enum_res = project_items_4_enum(items_4_enum);
+    assert(items_4_enum_res == 446);
+
+    let items_4_variants = K(446);
+    let items_4_variants_res = project_items_4_variants(items_4_variants);
+    assert(items_4_variants_res == 446);
+
+    let items_4_function_res = call_items_4_function();
+    assert(items_4_function_res == ITEMS_4_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 148 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_4_trait_teststruct_1_res = teststruct_1.items_4_trait_function(teststruct_2);
+    assert(items_4_trait_teststruct_1_res == 148);
+
+    let items_4_variants2 = M(446);
+    let items_4_variants2_res = project_items_4_variants2(items_4_variants2);
+    assert(items_4_variants2_res == 446);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/test.toml
new file mode 100755
index 00000000000..755870c91ef
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/shadowing_in_reexporting_module/test.toml
@@ -0,0 +1,5 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
+validate_abi = true
+expected_warnings = 19
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/Forc.lock
new file mode 100755
index 00000000000..12796c9cfa0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-01E3D9B036D3B866"
+
+[[package]]
+name = "simple_glob_import"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-01E3D9B036D3B866"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/Forc.toml
new file mode 100755
index 00000000000..e9e0963dbff
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "simple_glob_import"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/items_2.sw
new file mode 100755
index 00000000000..654a63ac267
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub n: u64,
+}
+
+pub enum Items2_Enum {
+    N: u64,
+    M: u64,
+}
+
+pub enum Items2_Variants {
+    O: u64,
+    P: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/lib_1.sw
new file mode 100644
index 00000000000..37a603bf191
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct;
+
+pub use ::items_1::Items1_Enum;
+
+pub use ::items_1::Items1_Variants::X;
+pub use ::items_1::Items1_Variants::Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function;
+
+pub use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/lib_2.sw
new file mode 100644
index 00000000000..8689296a943
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/lib_2.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_2::*;
+
+pub use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/main.sw
new file mode 100755
index 00000000000..57262307323
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2;
+mod lib_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/tests.sw
new file mode 100644
index 00000000000..fe487e264c3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/src/tests.sw
@@ -0,0 +1,126 @@
+library;
+
+use ::lib_1::*; // Reexported items from items_1.sw. All reexports are item imports
+use ::lib_2::*; // Reexported items from items_2.sw. All reexports are glob imports
+
+use ::items_1::Items1_Variants;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.n
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::N(val) => val,
+	Items2_Enum::M(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	O(val) => val,
+	P(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Items2_Struct { n: 789 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 789);
+
+    let items_2_enum = Items2_Enum::N(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = O(468);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/test.toml
new file mode 100755
index 00000000000..0b73866a32b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_glob_import/test.toml
@@ -0,0 +1,5 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
+validate_abi = true
+expected_warnings = 1
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/Forc.lock
new file mode 100755
index 00000000000..3153bd921ae
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-628D42C449EC89D5"
+
+[[package]]
+name = "simple_item_import"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-628D42C449EC89D5"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/Forc.toml
new file mode 100755
index 00000000000..37dd2996343
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "simple_item_import"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/items_2.sw
new file mode 100755
index 00000000000..654a63ac267
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub n: u64,
+}
+
+pub enum Items2_Enum {
+    N: u64,
+    M: u64,
+}
+
+pub enum Items2_Variants {
+    O: u64,
+    P: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/lib_1.sw
new file mode 100644
index 00000000000..37a603bf191
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct;
+
+pub use ::items_1::Items1_Enum;
+
+pub use ::items_1::Items1_Variants::X;
+pub use ::items_1::Items1_Variants::Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function;
+
+pub use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/lib_2.sw
new file mode 100644
index 00000000000..8689296a943
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/lib_2.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_2::*;
+
+pub use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/main.sw
new file mode 100755
index 00000000000..0b3777176d7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2;
+mod lib_2;  // Item reexports of items_2
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/tests.sw
new file mode 100644
index 00000000000..7a90a767dc2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/src/tests.sw
@@ -0,0 +1,142 @@
+library;
+
+ // Reexported items from items_1.sw. All reexports are item imports
+use ::lib_1::Items1_Struct;
+use ::lib_1::Items1_Enum;
+use ::lib_1::X;
+use ::lib_1::Y;
+use ::lib_1::ITEMS_1_FUNCTION_RES;
+use ::lib_1::items_1_function;
+use ::lib_1::Items1Trait;
+
+// Reexported items from items_2.sw. All reexports are glob imports
+use ::lib_2::Items2_Struct;
+use ::lib_2::Items2_Enum;
+use ::lib_2::Items2_Variants;
+use ::lib_2::O;
+use ::lib_2::P;
+use ::lib_2::ITEMS_2_FUNCTION_RES;
+use ::lib_2::items_2_function;
+use ::lib_2::Items2Trait;
+
+use ::items_1::Items1_Variants;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.n
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::N(val) => val,
+	Items2_Enum::M(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	O(val) => val,
+	P(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Items2_Struct { n: 789 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 789);
+
+    let items_2_enum = Items2_Enum::N(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = O(468);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/test.toml
new file mode 100755
index 00000000000..0b73866a32b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_item_import/test.toml
@@ -0,0 +1,5 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
+validate_abi = true
+expected_warnings = 1
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/Forc.lock
new file mode 100755
index 00000000000..a7cf53ac834
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-F3FE5D74B284BFAB"
+
+[[package]]
+name = "simple_path_access"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-F3FE5D74B284BFAB"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/Forc.toml
new file mode 100755
index 00000000000..dbc40b43ba1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "simple_path_access"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/json_abi_oracle_new_encoding.json
new file mode 100755
index 00000000000..068da3305ab
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/json_abi_oracle_new_encoding.json
@@ -0,0 +1,26 @@
+{
+  "configurables": [],
+  "encoding": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/items_2.sw
new file mode 100755
index 00000000000..250723123de
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub n: u64,
+}
+
+pub enum Items2_Enum {
+    N: u64,
+    M: u64,
+}
+
+pub enum Items2_Variants {
+    O: u64,
+    P: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/lib_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/lib_1.sw
new file mode 100644
index 00000000000..37a603bf191
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/lib_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct;
+
+pub use ::items_1::Items1_Enum;
+
+pub use ::items_1::Items1_Variants::X;
+pub use ::items_1::Items1_Variants::Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function;
+
+pub use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/lib_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/lib_2.sw
new file mode 100644
index 00000000000..8689296a943
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/lib_2.sw
@@ -0,0 +1,5 @@
+library;
+
+pub use ::items_2::*;
+
+pub use ::items_2::Items2_Variants::*;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/main.sw
new file mode 100755
index 00000000000..57262307323
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/main.sw
@@ -0,0 +1,12 @@
+script;
+
+mod items_1;
+mod lib_1;  // Item reexports of items_1
+mod items_2;
+mod lib_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/tests.sw
new file mode 100644
index 00000000000..b627b80a247
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/src/tests.sw
@@ -0,0 +1,97 @@
+library;
+
+// Disabled
+// This test is supposed to test that `pub use` makes items available when accessed using a path,
+// e.g., `::lib_1::X`, but the path resolution is broken, so the test doesn't test what it's
+// supposed to test.
+
+use ::items_1::Items1_Variants;
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+impl ::lib_1::Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+impl ::lib_2::Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+
+pub fn run_all_tests() -> u64 {
+    // lib_1 tests
+    let items_1_struct = ::lib_1::Items1_Struct { a: 123 };
+    assert(items_1_struct.a == 123);
+
+    let items_1_enum = ::lib_1::Items1_Enum::A(432);
+    let items_1_enum_res = match items_1_enum {
+	::items_1::Items1_Enum::A(val) => val,
+	::items_1::Items1_Enum::B(val) => val + 1000,
+    };
+    assert(items_1_enum_res == 432);
+
+    // TODO: Should this be allowed? ::lib_1::X refers to ::items_1::Items1_Variants::X.
+    let items_1_variants = ::lib_1::X(680);
+    let items_1_variants_res = match items_1_variants {
+	::items_1::Items1_Variants::X(val) => val,
+	::items_1::Items1_Variants::Y(val) => val + 1000,
+    };
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = ::lib_1::items_1_function();
+    let items_1_function_oracle = ::lib_1::ITEMS_1_FUNCTION_RES;
+    assert(items_1_function_res == items_1_function_oracle);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+    // lib_2 tests
+
+    let items_2_struct = ::lib_2::Items2_Struct { n: 789 };
+    assert(items_2_struct.n == 789);
+
+    let items_2_enum = ::lib_2::Items2_Enum::N(246);
+    let items_2_enum_res = match items_2_enum {
+	::items_2::Items2_Enum::N(val) => val,
+	::items_2::Items2_Enum::M(val) => val + 1000,
+    };
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = ::lib_2::O(468);
+    let items_2_variants_res = match items_2_variants {
+	::items_2::Items2_Variants::O(val) => val,
+	::items_2::Items2_Variants::P(val) => val + 1000,
+    };
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = ::lib_2::call_items_2_function();
+    let items_2_function_oracle = ::lib_2::ITEMS_2_FUNCTION_RES;
+    assert(items_2_function_res == items_2_function_oracle);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : false };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/test.toml
new file mode 100755
index 00000000000..f5c00c330c8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/simple_path_access/test.toml
@@ -0,0 +1,5 @@
+category = "disabled"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
+validate_abi = true
+expected_warnings = 0
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/Forc.lock
new file mode 100755
index 00000000000..70547186e1d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-3D27300F0A8AC1DF"
+
+[[package]]
+name = "std"
+source = "path+from-root-3D27300F0A8AC1DF"
+dependencies = ["core"]
+
+[[package]]
+name = "visibility"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/Forc.toml
new file mode 100755
index 00000000000..e690d8f1785
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "visibility"
+entry = "main.sw"
+implicit-std = false
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/json_abi_oracle.json
new file mode 100755
index 00000000000..2aa8f17eb3b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/items_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/items_1.sw
new file mode 100644
index 00000000000..45f1e280573
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/items_1.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items1_Struct {
+    pub a: u64,
+}
+
+pub enum Items1_Enum {
+    A: u64,
+    B: u64,
+}
+
+pub enum Items1_Variants {
+    X: u64,
+    Y: u64,
+}
+
+pub const ITEMS_1_FUNCTION_RES = 456;
+
+pub fn items_1_function() -> u64 {
+    ITEMS_1_FUNCTION_RES
+}
+
+pub trait Items1Trait<T> {
+    fn items_1_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/items_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/items_2.sw
new file mode 100755
index 00000000000..1fa9465b0ec
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/items_2.sw
@@ -0,0 +1,25 @@
+library;
+
+pub struct Items2_Struct {
+    pub b: u64,
+}
+
+pub enum Items2_Enum {
+    C: u64,
+    D: u64,
+}
+
+pub enum Items2_Variants {
+    Z: u64,
+    W: u64,
+}
+
+pub const ITEMS_2_FUNCTION_RES = 987;
+
+pub fn items_2_function() -> u64 {
+    ITEMS_2_FUNCTION_RES
+}
+
+pub trait Items2Trait<T> {
+    fn items_2_trait_function(self, x: T) -> bool;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_1_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_1_1.sw
new file mode 100644
index 00000000000..37a603bf191
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_1_1.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_1::Items1_Struct;
+
+pub use ::items_1::Items1_Enum;
+
+pub use ::items_1::Items1_Variants::X;
+pub use ::items_1::Items1_Variants::Y;
+
+pub use ::items_1::ITEMS_1_FUNCTION_RES;
+
+pub use ::items_1::items_1_function;
+
+pub use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_1_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_1_2.sw
new file mode 100644
index 00000000000..27a37d85825
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_1_2.sw
@@ -0,0 +1,14 @@
+library;
+
+use ::items_1::Items1_Struct;
+
+use ::items_1::Items1_Enum;
+
+use ::items_1::Items1_Variants::X;
+use ::items_1::Items1_Variants::Y;
+
+use ::items_1::ITEMS_1_FUNCTION_RES;
+
+use ::items_1::items_1_function;
+
+use ::items_1::Items1Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_2_1.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_2_1.sw
new file mode 100644
index 00000000000..b8b09eb5f35
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_2_1.sw
@@ -0,0 +1,14 @@
+library;
+
+use ::items_2::Items2_Struct;
+
+use ::items_2::Items2_Enum;
+
+use ::items_2::Items2_Variants::Z;
+use ::items_2::Items2_Variants::W;
+
+use ::items_2::ITEMS_2_FUNCTION_RES;
+
+use ::items_2::items_2_function;
+
+use ::items_2::Items2Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_2_2.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_2_2.sw
new file mode 100644
index 00000000000..825df78f630
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/lib_2_2.sw
@@ -0,0 +1,14 @@
+library;
+
+pub use ::items_2::Items2_Struct;
+
+pub use ::items_2::Items2_Enum;
+
+pub use ::items_2::Items2_Variants::Z;
+pub use ::items_2::Items2_Variants::W;
+
+pub use ::items_2::ITEMS_2_FUNCTION_RES;
+
+pub use ::items_2::items_2_function;
+
+pub use ::items_2::Items2Trait;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/main.sw
new file mode 100755
index 00000000000..078a2114541
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/main.sw
@@ -0,0 +1,14 @@
+script;
+
+mod items_1;
+mod lib_1_1;  // Item reexports of items_1
+mod lib_1_2;  // Item imports without reexport of items_1
+mod items_2;
+mod lib_2_1;  // Item imports without reexport of items_1
+mod lib_2_2;  // Item reexports of items_1
+
+mod tests; // All tests
+
+fn main() -> u64 {
+    tests::run_all_tests()
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/tests.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/tests.sw
new file mode 100644
index 00000000000..d03441d6016
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/src/tests.sw
@@ -0,0 +1,128 @@
+library;
+
+use ::lib_1_1::*; // Reexported items from items_1.sw. 
+use ::lib_1_2::*; // Imported but not reexported items from items_1.sw. 
+use ::lib_2_1::*; // Imported but not reexported items from items_2.sw.
+use ::lib_2_2::*; // Reexported items from items_2.sw.
+
+use ::items_1::Items1_Variants;
+use ::items_2::Items2_Variants;
+
+
+// Helper types
+
+struct TestStruct1 {
+    Z: u64,
+}
+
+struct TestStruct2 {
+    W: bool,
+}
+
+
+// lib_1 tests
+
+fn project_items_1_struct(input: Items1_Struct) -> u64 {
+    input.a
+}
+
+fn project_items_1_enum(input: Items1_Enum) -> u64 {
+    match input {
+	Items1_Enum::A(val) => val,
+	Items1_Enum::B(val) => val + 1000,
+    }
+}
+
+fn project_items_1_variants(input: Items1_Variants) -> u64 {
+    match input {
+	X(val) => val,
+	Y(val) => val + 1000,
+    }
+}
+
+fn call_items_1_function() -> u64 {
+    items_1_function()
+}
+
+impl Items1Trait<TestStruct2> for TestStruct1 {
+    fn items_1_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 64 && x.W
+    }
+}
+
+
+// lib_2 tests
+
+fn project_items_2_struct(input: Items2_Struct) -> u64 {
+    input.b
+}
+
+fn project_items_2_enum(input: Items2_Enum) -> u64 {
+    match input {
+	Items2_Enum::C(val) => val,
+	Items2_Enum::D(val) => val + 1000,
+    }
+}
+
+fn project_items_2_variants(input: Items2_Variants) -> u64 {
+    match input {
+	Z(val) => val,
+	W(val) => val + 1000,
+    }
+}
+
+fn call_items_2_function() -> u64 {
+    items_2_function()
+}
+
+impl Items2Trait<TestStruct2> for TestStruct1 {
+    fn items_2_trait_function(self, x: TestStruct2) -> bool {
+	self.Z == 128 && x.W
+    }
+}
+
+
+pub fn run_all_tests() -> u64 {
+    let items_1_struct = Items1_Struct { a: 123 };
+    let items_1_struct_res = project_items_1_struct(items_1_struct);
+    assert(items_1_struct_res == 123);
+
+    let items_1_enum = Items1_Enum::A(432);
+    let items_1_enum_res = project_items_1_enum(items_1_enum);
+    assert(items_1_enum_res == 432);
+
+    let items_1_variants = X(680);
+    let items_1_variants_res = project_items_1_variants(items_1_variants);
+    assert(items_1_variants_res == 680);
+
+    let items_1_function_res = call_items_1_function();
+    assert(items_1_function_res == ITEMS_1_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 64 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_1_trait_teststruct_1_res = teststruct_1.items_1_trait_function(teststruct_2);
+    assert(items_1_trait_teststruct_1_res);
+
+
+    let items_2_struct = Items2_Struct { b: 789 };
+    let items_2_struct_res = project_items_2_struct(items_2_struct);
+    assert(items_2_struct_res == 789);
+
+    let items_2_enum = Items2_Enum::C(246);
+    let items_2_enum_res = project_items_2_enum(items_2_enum);
+    assert(items_2_enum_res == 246);
+
+    let items_2_variants = Z(468);
+    let items_2_variants_res = project_items_2_variants(items_2_variants);
+    assert(items_2_variants_res == 468);
+
+    let items_2_function_res = call_items_2_function();
+    assert(items_2_function_res == ITEMS_2_FUNCTION_RES);
+
+    let teststruct_1 = TestStruct1 { Z : 128 };
+    let teststruct_2 = TestStruct2 { W : true };
+    let items_2_trait_teststruct_1_res = teststruct_1.items_2_trait_function(teststruct_2);
+    assert(items_2_trait_teststruct_1_res);
+
+    42
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/test.toml
new file mode 100755
index 00000000000..5341fe8486c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/reexport/visibility/test.toml
@@ -0,0 +1,5 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
+validate_abi = true
+expected_warnings = 0
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_bool/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_bool/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_bool/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_bool/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_call/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_call/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_call/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_call/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct_assign/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct_assign/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct_assign/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_struct_assign/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_u32/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_u32/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_u32/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ref_mutable_fn_args_u32/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_small_string/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_small_string/json_abi_oracle_new_encoding.json
index 8a40e7a2984..2785b32ab24 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_small_string/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_small_string/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "0a92c8e0f509a2d3a66f68dd50408ce45a1a2596803b0bc983a69b34bd40dad2",
+      "type": "str[3]"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "0a92c8e0f509a2d3a66f68dd50408ce45a1a2596803b0bc983a69b34bd40dad2"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "str[3]",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_string_in_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_string_in_struct/json_abi_oracle_new_encoding.json
index 19570ea7986..6166d46c699 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_string_in_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/ret_string_in_struct/json_abi_oracle_new_encoding.json
@@ -1,38 +1,39 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "fff091c1b987e0dabd44005f2ff24bd4a58ae5a2e6225b261dbd8812592472fe",
+      "metadataTypeId": 1,
+      "type": "struct Wrapper"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "fff091c1b987e0dabd44005f2ff24bd4a58ae5a2e6225b261dbd8812592472fe"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": null,
-      "type": "str[9]",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "str[9]"
     },
     {
       "components": [
         {
           "name": "name",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct Wrapper",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "struct Wrapper"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_b256/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_b256/json_abi_oracle_new_encoding.json
index 5cc58c95131..36d7f625c38 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_b256/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_b256/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_small_array/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_small_array/json_abi_oracle_new_encoding.json
index cdce150e08c..4e7e23a6f3a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_small_array/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_small_array/json_abi_oracle_new_encoding.json
@@ -1,38 +1,39 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1327785bbe4ca72fe0dc2e24483357df172feed9833c4048f05d9bb741d6c813",
+      "metadataTypeId": 0,
+      "type": "[u32; 1]"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1327785bbe4ca72fe0dc2e24483357df172feed9833c4048f05d9bb741d6c813"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 1
         }
       ],
-      "type": "[_; 1]",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "[_; 1]"
     },
     {
-      "components": null,
-      "type": "u32",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "u32"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_struct/json_abi_oracle_new_encoding.json
index d43cc168090..70d0e8d8ab3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_struct/json_abi_oracle_new_encoding.json
@@ -1,72 +1,65 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "389b2ea3cbdf4d5643e7c700fa138ffafdfdd9f8b756241f030679d7c17012b8",
+      "metadataTypeId": 2,
+      "type": "struct BiggerThanAWord"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "389b2ea3cbdf4d5643e7c700fa138ffafdfdd9f8b756241f030679d7c17012b8"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 4
         }
       ],
-      "type": "[_; 2]",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "[_; 2]"
     },
     {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "b256"
     },
     {
       "components": [
         {
           "name": "field_1",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 3
         },
         {
           "name": "field_2",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 1
         },
         {
           "name": "field_3",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct BiggerThanAWord",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "struct BiggerThanAWord"
     },
     {
-      "components": null,
-      "type": "u64",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "u64"
     },
     {
-      "components": null,
-      "type": "u8",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "u8"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_zero_len_array/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_zero_len_array/json_abi_oracle_new_encoding.json
index 63afb0181c9..983f51b0a4b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_zero_len_array/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/retd_zero_len_array/json_abi_oracle_new_encoding.json
@@ -1,38 +1,39 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "ad5cceb591a12bb56461db8eb039b1433f0624d68fd773ed66707a3facfe0b9f",
+      "metadataTypeId": 0,
+      "type": "[u32; 0]"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "ad5cceb591a12bb56461db8eb039b1433f0624d68fd773ed66707a3facfe0b9f"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 1
         }
       ],
-      "type": "[_; 0]",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "[_; 0]"
     },
     {
-      "components": null,
-      "type": "u32",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "u32"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/self_impl_reassignment/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/self_impl_reassignment/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/self_impl_reassignment/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/self_impl_reassignment/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/lib.sw
index 1b56f4e904f..44e1420d02a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/lib.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/lib.sw
@@ -1,7 +1,9 @@
 library;
 
-pub const X1 = 5;
-pub const X2 = 5;
+pub const X1: u64 = 5;
+pub const X2: u64 = 5;
+pub const X3: u64 = 5;
+
 pub struct MyStruct11 {}
 pub enum MyEnum12 {}
 pub trait MyTrait13 {}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/main.sw
index 06649cbd36a..e59fe4c773c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/src/main.sw
@@ -6,7 +6,7 @@ mod lib;
 use lib::*;
 
 // const shadowing an imported const with glob 
-const X1 = 7;
+const X1: u64 = 0;
 
 // types and traits shadowing imported items with glob 
 struct MyStruct11 {}
@@ -32,8 +32,13 @@ enum MyAbi24 {}
 trait MyAbi34 {}
 abi MyAbi44 {}
 
+configurable {
+    X3: u64 = 22,
+}
 
-fn main() {
+fn main() -> u64 {
     // var shadowing an imported const with glob
-    let X2 = 4;
+    let X2 = 20;
+
+    X1 + X2 + X3
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/test.toml
index 75b5f2ef5a2..81416a67cb2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/shadowing/shadowed_glob_imports/test.toml
@@ -1,2 +1,4 @@
-category = "compile"
+category = "run"
+expected_result = { action = "return", value = 42 }
+expected_result_new_encoding = { action = "return_data", value = "000000000000002A" }
 expected_warnings = 27
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/size_of/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/size_of/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/size_of/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/size_of/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/Forc.lock
new file mode 100644
index 00000000000..5c7705f6e4a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/Forc.lock
@@ -0,0 +1,16 @@
+[[package]]
+name = "core"
+source = "path+from-root-FF18DE8D9DD80114"
+
+[[package]]
+name = "slice_contract"
+source = "member"
+dependencies = [
+    "core",
+    "std",
+]
+
+[[package]]
+name = "std"
+source = "path+from-root-FF18DE8D9DD80114"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/Forc.toml
new file mode 100644
index 00000000000..376aecfff43
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "slice_contract"
+
+[dependencies]
+core = { path = "../../../../../../../../sway-lib-core" }
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..9ccfe9e575c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/json_abi_oracle_new_encoding.json
@@ -0,0 +1,32 @@
+{
+  "configurables": [],
+  "encoding": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "name": "a",
+          "type": 0,
+          "typeArguments": null
+        }
+      ],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "str",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/src/main.sw
new file mode 100644
index 00000000000..c86ce974d88
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/src/main.sw
@@ -0,0 +1,22 @@
+contract;
+
+abi MyContract {
+    fn test_function(a: raw_slice) -> raw_slice;
+}
+
+impl MyContract for Contract {
+    fn test_function(a: raw_slice) -> raw_slice {
+        a
+    }
+}
+
+#[test]
+fn test_success() {
+    let caller = abi(MyContract, CONTRACT_ID);
+
+    let data = 1u64;
+    let slice = raw_slice::from_parts::<u64>(__addr_of(&data), 1);
+    let result = caller.test_function(slice);
+    
+    assert(result.len::<u8>() == slice.len::<u8>());
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/test.toml
new file mode 100644
index 00000000000..e970e053286
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_contract/test.toml
@@ -0,0 +1,2 @@
+category = "unit_tests_pass"
+unsupported_profiles = ["debug"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/Forc.lock
new file mode 100644
index 00000000000..a7de4b3565f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/Forc.lock
@@ -0,0 +1,16 @@
+[[package]]
+name = "core"
+source = "path+from-root-53D6DC514F06A250"
+
+[[package]]
+name = "slice_intrinsics"
+source = "member"
+dependencies = [
+    "core",
+    "utils",
+]
+
+[[package]]
+name = "utils"
+source = "path+from-root-53D6DC514F06A250"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/Forc.toml
new file mode 100644
index 00000000000..fe47736bbcf
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "slice_intrinsics"
+
+[dependencies]
+core = { path = "../../../../../../../../sway-lib-core" }
+utils = { path = "../../../../../../../../test/src/e2e_vm_tests/utils" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_constants/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..bf5debeec20
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/json_abi_oracle_new_encoding.json
@@ -0,0 +1,32 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
+    }
+  ],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/src/main.sw
new file mode 100644
index 00000000000..8b094c836ab
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/src/main.sw
@@ -0,0 +1,183 @@
+script;
+
+use utils::*;
+
+fn alloc_slice<T>(len: u64) -> &mut __slice[T] {
+    let size_in_bytes = len * __size_of::<T>();
+    let ptr = asm(size_in_bytes: size_in_bytes) {
+        aloc size_in_bytes;
+        hp: raw_ptr
+    };
+    asm(buf: (ptr,  len)) {
+        buf: &mut __slice[T]
+    }
+}
+
+fn realloc_slice<T>(old: &mut __slice[T], len: u64) -> &mut __slice[T] {
+    let old_ptr = old.ptr();
+    let old_len_in_bytes = old.len() * __size_of::<T>();
+
+    let new_len_in_bytes = len * __size_of::<T>();
+    let new_ptr = asm(new_len_in_bytes: new_len_in_bytes, old_ptr: old_ptr, old_len_in_bytes: old_len_in_bytes) {
+        aloc new_len_in_bytes;
+        mcp hp old_ptr old_len_in_bytes;
+        hp: raw_ptr
+    };
+
+    asm(buf: (new_ptr,  len)) {
+        buf: &mut __slice[T]
+    }
+}
+
+pub struct Vec<T> {
+    buf: &mut __slice[T],
+    len: u64,
+}
+
+impl<T> Dbg for Vec<T> {
+    fn dbg(self) {
+        (
+            "Vec { buf: (ptr: ",
+            asm(v: self.buf.ptr()) { v: u64 },
+            ", len: ",
+            self.buf.len(),
+            "), len: ",
+            self.len,
+            ")"
+        ).dbg();
+    }
+}
+
+
+impl<T> Vec<T> {
+    pub fn new() -> Self {
+        Self {
+            buf: alloc_slice::<T>(0),
+            len: 0
+        }
+    }
+
+    pub fn push(ref mut self, item: T) {
+        "Vec::push(...)".dbgln();
+        ("    ", self).dbgln();
+
+        let new_item_idx = self.len;
+        let current_cap = self.buf.len();
+        if new_item_idx >= current_cap {
+            let new_cap = if current_cap == 0 {
+                1
+            } else {
+                current_cap * 2
+            };
+            self.buf = realloc_slice(self.buf, new_cap);
+            ("    After realloc: ", self).dbgln();
+        }
+
+        let v: &mut T = __elem_at(self.buf, new_item_idx);
+
+        let buffer_addr = asm(v: self.buf.ptr()) { v: u64 };
+        let elem_addr = asm(v: v) { v: u64 };
+        ("    elem ", new_item_idx, " at ", elem_addr, " buffer offset (in bytes): ", elem_addr - buffer_addr).dbgln();
+        *v = item;
+
+        self.len += 1;
+
+        ("    ", self).dbgln();
+    }
+
+    pub fn get(self, index: u64) -> T {
+        ("Vec::get(", index, ")").dbgln();
+        ("    ", self).dbgln();
+
+        let item: &mut T = __elem_at(self.buf, index);
+
+        let buffer_addr = asm(v: self.buf.ptr()) { v: u64 };
+        let elem_addr = asm(v: item) { v: u64 };
+        ("    element ", index, " at ", elem_addr, " buffer offset (in bytes): ", elem_addr - buffer_addr).dbgln();
+
+        *item
+    }
+}
+
+fn assert<T>(l: T, r: T)
+where
+    T: Eq + AbiEncode
+{
+    if l != r {
+        __log(l);
+        __log(r);
+        __revert(1)
+    }
+}
+
+fn type_check() {
+    let immutable_array: [u64; 5] = [1, 2, 3, 4, 5];
+    let _: &u64 = __elem_at(&immutable_array, 0);
+
+    let mut mutable_array: [u64; 5] = [1, 2, 3, 4, 5];
+    let _: &u64 = __elem_at(&mutable_array, 0);
+    let _: &mut u64 = __elem_at(&mut mutable_array, 0);
+    let _: &u64 = __elem_at(&mut mutable_array, 0);
+
+    let immutable_slice: &__slice[u64] = __slice(&immutable_array, 0, 5);
+    let _: &u64 = __elem_at(immutable_slice, 0);
+
+    let mutable_slice: &mut __slice[u64] = __slice(&mut mutable_array, 0, 5);
+    let _: &mut u64 = __elem_at(mutable_slice, 0);
+    let _: &u64 = __elem_at(mutable_slice, 0);
+}
+
+fn main()  {
+    type_check();
+
+    // index arrays
+    let some_array: [u64; 5] = [1, 2, 3, 4, 5];
+    assert(1, *__elem_at(&some_array, 0));
+    assert(2, *__elem_at(&some_array, 1));
+    assert(3, *__elem_at(&some_array, 2));
+    assert(4, *__elem_at(&some_array, 3));
+    assert(5, *__elem_at(&some_array, 4));
+
+    // slice arrays
+    let some_slice: &__slice[u64] = __slice(&some_array, 0, 5);
+    assert(1, *__elem_at(some_slice, 0));
+    assert(2, *__elem_at(some_slice, 1));
+    assert(3, *__elem_at(some_slice, 2));
+    assert(4, *__elem_at(some_slice, 3));
+    assert(5, *__elem_at(some_slice, 4));
+
+    // slice another slice
+    let another_slice: &__slice[u64] = __slice(some_slice, 1, 4);
+    assert(2, *__elem_at(another_slice, 0));
+    assert(3, *__elem_at(another_slice, 1));
+    assert(4, *__elem_at(another_slice, 2));
+
+    // Vec impl using slices
+    let mut v: Vec<u64> = Vec::new();
+    v.push(1);
+    assert(v.get(0), 1);
+
+    v.push(2);
+    v.push(3);
+    assert(v.get(0), 1);
+    assert(v.get(1), 2);
+    assert(v.get(2), 3);
+
+    v.push(4);
+    v.push(5);
+    v.push(6);
+    v.push(7);
+    assert(v.get(0), 1);
+    assert(v.get(1), 2);
+    assert(v.get(2), 3);
+    assert(v.get(3), 4);
+    assert(v.get(4), 5);
+    assert(v.get(5), 6);
+    assert(v.get(6), 7);
+
+    //indices as expressions
+    assert(2, *__elem_at(&some_array, v.get(0)));
+
+    let _some_slice: &__slice[u64] = __slice(&some_array, v.get(0), v.get(4));
+    assert(2, *__elem_at(some_slice, v.get(0)));
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/test.toml
similarity index 57%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/test.toml
index 156a03feb89..dae3eb53b08 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_intrinsics/test.toml
@@ -1,4 +1,7 @@
 category = "run"
-expected_result = { action = "return", value = 100 }
-expected_result_new_encoding = { action = "return_data", value = "0000000000000064" }
+
+category_new_encoding = "run"
+script_data_new_encoding = ""
+expected_result_new_encoding = { action = "return_data", value = "" }
+
 validate_abi = true
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/Forc.lock
similarity index 53%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/Forc.lock
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/Forc.lock
index 7a21e06dfe5..21e4b136278 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/const_decl_literal/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/Forc.lock
@@ -1,8 +1,8 @@
 [[package]]
-name = "const_decl_literal"
-source = "member"
-dependencies = ["core"]
+name = "core"
+source = "path+from-root-EF772967F47251DB"
 
 [[package]]
-name = "core"
-source = "path+from-root-CF582537254C5032"
+name = "slice_script"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/Forc.toml
new file mode 100644
index 00000000000..4cc0ca42249
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "slice_script"
+
+[dependencies]
+core = { path = "../../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/json_abi_oracle.json
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/json_abi_oracle.json
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..dfbd54db3a4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/json_abi_oracle_new_encoding.json
@@ -0,0 +1,28 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1e1c7c52c1c7a9901681337f8669555f62aac58911332c9ff6b4ea8e73786570",
+      "type": "raw untyped slice"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "concreteTypeId": "1e1c7c52c1c7a9901681337f8669555f62aac58911332c9ff6b4ea8e73786570",
+          "name": "a"
+        }
+      ],
+      "name": "main",
+      "output": "1e1c7c52c1c7a9901681337f8669555f62aac58911332c9ff6b4ea8e73786570"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/src/main.sw
new file mode 100644
index 00000000000..2375ae3ed98
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/src/main.sw
@@ -0,0 +1,5 @@
+script;
+
+fn main(a: raw_slice) -> raw_slice {
+    a
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/test.toml
new file mode 100644
index 00000000000..d238049781f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/slice/slice_script/test.toml
@@ -0,0 +1,10 @@
+category = "fail"
+
+# check: $()fn main(a: raw_slice) -> raw_slice
+# nextln: $()Returning a type containing `raw_slice` from `main()` is not allowed. Consider converting it into a flat `raw_slice` first
+
+category_new_encoding = "run"
+script_data_new_encoding = "0000000000000001 65"
+expected_result_new_encoding = { action = "return_data", value = "0000000000000001 65" }
+
+validate_abi = true
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/smo/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/smo/json_abi_oracle_new_encoding.json
index 27b39b8702e..2ab312180d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/smo/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/smo/json_abi_oracle_new_encoding.json
@@ -1,262 +1,202 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2dc21094c0e9d81b843d1c1c308e2d60755d727d0f9b8981389845dd6d8686b2",
+      "metadataTypeId": 1,
+      "type": "[u8; 3]"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "4ca93e765958806c8bb1d93e48c7d359f5c949785cc571959c2d6a985a389e08",
+      "metadataTypeId": 2,
+      "type": "enum Option<struct TestStruct<u64>>",
+      "typeArguments": [
+        "4a28f33bb57426a71884323fb9163c851f60c723dce949f3860dc2a97d06792b"
+      ]
+    },
+    {
+      "concreteTypeId": "f51956598ea2c3f8b9d3fae025e2d1bceda1e29e13a0a0d44e613596c7b20bea",
+      "metadataTypeId": 3,
+      "type": "enum TestEnum"
+    },
+    {
+      "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a",
+      "type": "str"
+    },
+    {
+      "concreteTypeId": "5707520cd48d332d49e92fe0626d70391cda07cf95fe651f1656a18a013da11d",
+      "metadataTypeId": 5,
+      "type": "struct TestStruct<b256>",
+      "typeArguments": [
+        "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
+      ]
+    },
+    {
+      "concreteTypeId": "4a28f33bb57426a71884323fb9163c851f60c723dce949f3860dc2a97d06792b",
+      "metadataTypeId": 5,
+      "type": "struct TestStruct<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "10098701174489624218",
-      "loggedType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": null
-      }
+      "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a",
+      "logId": "10098701174489624218"
     },
     {
-      "logId": "3297216108266379291",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "2dc21094c0e9d81b843d1c1c308e2d60755d727d0f9b8981389845dd6d8686b2",
+      "logId": "3297216108266379291"
     }
   ],
   "messagesTypes": [
     {
-      "messageId": 0,
-      "messageType": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "messageId": "0"
     },
     {
-      "messageId": 1,
-      "messageType": {
-        "name": "",
-        "type": 11,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "messageId": "1"
     },
     {
-      "messageId": 2,
-      "messageType": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      }
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "messageId": "2"
     },
     {
-      "messageId": 3,
-      "messageType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "messageId": "3"
     },
     {
-      "messageId": 4,
-      "messageType": {
-        "name": "",
-        "type": 12,
-        "typeArguments": null
-      }
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "messageId": "4"
     },
     {
-      "messageId": 5,
-      "messageType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": null
-      }
+      "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a",
+      "messageId": "5"
     },
     {
-      "messageId": 6,
-      "messageType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "2dc21094c0e9d81b843d1c1c308e2d60755d727d0f9b8981389845dd6d8686b2",
+      "messageId": "6"
     },
     {
-      "messageId": 7,
-      "messageType": {
-        "name": "",
-        "type": 8,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 2,
-            "typeArguments": null
-          }
-        ]
-      }
+      "concreteTypeId": "5707520cd48d332d49e92fe0626d70391cda07cf95fe651f1656a18a013da11d",
+      "messageId": "7"
     },
     {
-      "messageId": 8,
-      "messageType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": []
-      }
+      "concreteTypeId": "f51956598ea2c3f8b9d3fae025e2d1bceda1e29e13a0a0d44e613596c7b20bea",
+      "messageId": "8"
     },
     {
-      "messageId": 9,
-      "messageType": {
-        "name": "",
-        "type": 4,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 8,
-            "typeArguments": [
-              {
-                "name": "",
-                "type": 11,
-                "typeArguments": null
-              }
-            ]
-          }
-        ]
-      }
+      "concreteTypeId": "4ca93e765958806c8bb1d93e48c7d359f5c949785cc571959c2d6a985a389e08",
+      "messageId": "9"
     }
   ],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 12,
-          "typeArguments": null
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
         }
       ],
-      "type": "[_; 3]",
-      "typeId": 1,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "[_; 3]"
     },
     {
       "components": [
         {
           "name": "None",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "Some",
-          "type": 6,
-          "typeArguments": null
+          "typeId": 4
         }
       ],
+      "metadataTypeId": 2,
       "type": "enum Option",
-      "typeId": 4,
       "typeParameters": [
-        6
+        4
       ]
     },
     {
       "components": [
         {
           "name": "VariantOne",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "VariantTwo",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "enum TestEnum",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "enum TestEnum"
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 6,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "generic T"
     },
     {
       "components": [
         {
           "name": "field_1",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         },
         {
           "name": "field_2",
-          "type": 6,
-          "typeArguments": null
+          "typeId": 4
         },
         {
           "name": "field_3",
-          "type": 11,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 5,
       "type": "struct TestStruct",
-      "typeId": 8,
       "typeParameters": [
-        6
+        4
       ]
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 9,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 10,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 11,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 12,
-      "typeParameters": null
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/Forc.lock
new file mode 100644
index 00000000000..c4fb43d339a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/Forc.lock
@@ -0,0 +1,16 @@
+[[package]]
+name = "core"
+source = "path+from-root-3FD9E4EB10C615E3"
+
+[[package]]
+name = "std"
+source = "path+from-root-3FD9E4EB10C615E3"
+dependencies = ["core"]
+
+[[package]]
+name = "string_slice_contract"
+source = "member"
+dependencies = [
+    "core",
+    "std",
+]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/Forc.toml
new file mode 100644
index 00000000000..38f1c81344d
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "string_slice_contract"
+
+[dependencies]
+core = { path = "../../../../../../../../sway-lib-core" }
+std = { path = "../../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/json_abi_oracle.json
similarity index 87%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/json_abi_oracle.json
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/json_abi_oracle.json
index fad72a08f17..ad50b55d54c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm_without_return/json_abi_oracle.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/json_abi_oracle.json
@@ -16,8 +16,8 @@
   "messagesTypes": [],
   "types": [
     {
-      "components": [],
-      "type": "()",
+      "components": null,
+      "type": "u64",
       "typeId": 0,
       "typeParameters": null
     }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..9ccfe9e575c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/json_abi_oracle_new_encoding.json
@@ -0,0 +1,32 @@
+{
+  "configurables": [],
+  "encoding": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "name": "a",
+          "type": 0,
+          "typeArguments": null
+        }
+      ],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "str",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/src/main.sw
new file mode 100644
index 00000000000..70cb24b5ef9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/src/main.sw
@@ -0,0 +1,18 @@
+contract;
+
+abi MyContract {
+    fn test_function(a: str) -> str;
+}
+
+impl MyContract for Contract {
+    fn test_function(a: str) -> str {
+        a
+    }
+}
+
+#[test]
+fn test_success() {
+    let caller = abi(MyContract, CONTRACT_ID); 
+    let result = caller.test_function("a");
+    assert(result == "a")
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/test.toml
new file mode 100644
index 00000000000..e970e053286
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_contract/test.toml
@@ -0,0 +1,2 @@
+category = "unit_tests_pass"
+unsupported_profiles = ["debug"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/Forc.lock
new file mode 100644
index 00000000000..11d4814e409
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-FB31F3B8BBBDDB33"
+
+[[package]]
+name = "string_slice_features"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/Forc.toml
new file mode 100644
index 00000000000..419c834c6aa
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "string_slice_features"
+
+[dependencies]
+core = { path = "../../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/json_abi_oracle.json
new file mode 100644
index 00000000000..ad50b55d54c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..05b0f04b2d3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/json_abi_oracle_new_encoding.json
@@ -0,0 +1,23 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/src/main.sw
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/src/main.sw
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/src/main.sw
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/test.toml
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/str_slice/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_features/test.toml
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/Forc.lock
new file mode 100644
index 00000000000..a629d094533
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-A528390DA52F2C73"
+
+[[package]]
+name = "string_slice_script"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/Forc.toml
new file mode 100644
index 00000000000..1b469ad316e
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "string_slice_script"
+
+[dependencies]
+core = { path = "../../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/json_abi_oracle.json
new file mode 100644
index 00000000000..ad50b55d54c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/json_abi_oracle.json
@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..79842b24ed9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/json_abi_oracle_new_encoding.json
@@ -0,0 +1,28 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a",
+      "type": "str"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "concreteTypeId": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a",
+          "name": "a"
+        }
+      ],
+      "name": "main",
+      "output": "8c25cb3686462e9a86d2883c5688a22fe738b0bbc85f458d2d2b5f3f667c6d5a"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/src/main.sw
new file mode 100644
index 00000000000..0caf7cfae6c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/src/main.sw
@@ -0,0 +1,5 @@
+script;
+
+fn main(a: str) -> str {
+    a
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/test.toml
new file mode 100644
index 00000000000..15e5e0cd080
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/string_slice/string_slice_script/test.toml
@@ -0,0 +1,13 @@
+category = "fail"
+
+# check: $()fn main(a: str) -> str
+# nextln: $()`str` or a type containing `str` on `main()` arguments is not allowed
+
+# check: $()fn main(a: str) -> str
+# nextln: $()Returning `str` or a type containing `str` from `main()` is not allowed
+
+category_new_encoding = "run"
+script_data_new_encoding = "0000000000000001 65"
+expected_result_new_encoding = { action = "return_data", value = "0000000000000001 65" }
+
+validate_abi = true
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_destructuring/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_access/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_access/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_access/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_access/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_reassignment/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_reassignment/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_reassignment/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_field_reassignment/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_instantiation/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_instantiation/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_instantiation/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/struct_instantiation/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits_with_trait_methods/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits_with_trait_methods/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits_with_trait_methods/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/supertraits_with_trait_methods/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/Forc.lock
new file mode 100644
index 00000000000..27664e3bf63
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-AA6BA29B6C5ED809"
+
+[[package]]
+name = "std"
+source = "path+from-root-AA6BA29B6C5ED809"
+dependencies = ["core"]
+
+[[package]]
+name = "totalord"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/Forc.toml
new file mode 100644
index 00000000000..fbde59dd326
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "totalord"
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/json_abi_oracle.json
new file mode 100644
index 00000000000..5d9532112a9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/json_abi_oracle.json
@@ -0,0 +1,64 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    }
+  ],
+  "loggedTypes": [
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "logId": "14454674236531057292"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "logId": "2992671284987479467"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "logId": "15520703124961489725"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "logId": "1970142151624111756"
+    }
+  ],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..5d9532112a9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/json_abi_oracle_new_encoding.json
@@ -0,0 +1,64 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
+    }
+  ],
+  "loggedTypes": [
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "logId": "14454674236531057292"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "logId": "2992671284987479467"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "logId": "15520703124961489725"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "logId": "1970142151624111756"
+    }
+  ],
+  "messagesTypes": [],
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/src/main.sw
new file mode 100644
index 00000000000..81e8e852ad6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/src/main.sw
@@ -0,0 +1,138 @@
+script;
+
+use std::u128::*;
+
+fn test_totalord_u8() {
+    let a = 10u8;
+    let b = 20u8;
+
+    let max = a.max(b);
+    assert_eq(max, 20u8);
+
+    let min = a.min(b);
+    assert_eq(min, 10u8);
+
+    let c = 30u8;
+    let d = 30u8;
+
+    let max = c.max(d);
+    assert_eq(max, 30u8);
+
+    let min = c.min(d);
+    assert_eq(min, 30u8);
+}
+
+fn test_totalord_u16() {
+    let a = 10u16;
+    let b = 20u16;
+
+    let max = a.max(b);
+    assert_eq(max, 20);
+
+    let min = a.min(b);
+    assert_eq(min, 10);
+
+    let c = 30u16;
+    let d = 30u16;
+
+    let max = c.max(d);
+    assert_eq(max, 30);
+
+    let min = c.min(d);
+    assert_eq(min, 30);
+}
+
+fn test_totalord_u32() {
+    let a = 10u32;
+    let b = 20u32;
+
+    let max = a.max(b);
+    assert_eq(max, 20u32);
+
+    let min = a.min(b);
+    assert_eq(min, 10u32);
+
+    let c = 30u32;
+    let d = 30u32;
+
+    let max = c.max(d);
+    assert_eq(max, 30u32);
+
+    let min = c.min(d);
+    assert_eq(min, 30u32);
+}
+
+fn test_totalord_u64() {
+    let a = 10;
+    let b = 20;
+
+    let max = a.max(b);
+    assert_eq(max, 20);
+
+    let min = a.min(b);
+    assert_eq(min, 10);
+
+    let c = 30;
+    let d = 30;
+
+    let max = c.max(d);
+    assert_eq(max, 30);
+
+    let min = c.min(d);
+    assert_eq(min, 30);
+}
+
+fn test_totalord_u128() {
+    let a = U128::from((0, 0));
+    let b = U128::from((0, 1));
+
+    let max = a.max(b);
+    assert(max.upper() == 0);
+    assert(max.lower() == 1);
+
+    let min = a.min(b);
+    assert(min.upper() == 0);
+    assert(min.lower() == 0);
+
+    let c = U128::from((2, 2));
+    let d = U128::from((2, 2));
+
+    let max = c.max(d);
+    assert(max.upper() == 2);
+    assert(max.lower() == 2);
+
+    let min = c.min(d);
+    assert(min.upper() == 2);
+    assert(min.lower() == 2);
+}
+
+fn test_totalord_u256() {
+    let a = 0x01u256;
+    let b = 0x02u256;
+
+    let max = a.max(b);
+    assert_eq(max, 0x02u256);
+
+    let min = a.min(b);
+    assert_eq(min, 0x01u256);
+
+    let c = 0x03u256;
+    let d = 0x03u256;
+
+    let max = c.max(d);
+    assert_eq(max, 0x03u256);
+
+    let min = c.min(d);
+    assert_eq(min, 0x03u256);
+}
+
+fn main() -> bool {
+    test_totalord_u8();
+    test_totalord_u16();
+    test_totalord_u32();
+    test_totalord_u64();
+    test_totalord_u128();
+    test_totalord_u256();
+
+    true
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/test.toml
similarity index 78%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/test.toml
index 67ab8164b7f..53fb5ce9a94 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/associated_const_impl_self_order/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/totalord/test.toml
@@ -1,4 +1,4 @@
 category = "run"
 expected_result = { action = "return", value = 1 }
-expected_result_new_encoding = { action = "return_data", value = "00000001" }
-expected_warnings = 2
+expected_result_new_encoding = { action = "return_data", value = "01" }
+validate_abi = true
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_import_with_star/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_import_with_star/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_import_with_star/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_import_with_star/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/Forc.lock
new file mode 100644
index 00000000000..883e47a2785
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-3903213068BE1E4C"
+
+[[package]]
+name = "std"
+source = "path+from-root-3903213068BE1E4C"
+dependencies = ["core"]
+
+[[package]]
+name = "trait_inference"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/Forc.toml
new file mode 100644
index 00000000000..56507e6db8f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "trait_inference"
+
+[dependencies]
+std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/src/main.sw
new file mode 100644
index 00000000000..31144e281c8
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/src/main.sw
@@ -0,0 +1,41 @@
+script;
+
+pub trait MyFrom<T> {
+    fn from(b: T) -> Self;
+}
+
+
+pub trait MyInto<T> {
+    fn into(self) -> T;
+}
+
+
+impl<T, U> MyInto<U> for T
+where
+    U: MyFrom<T>,
+{
+    fn into(self) -> U {
+        U::from(self)
+    }
+}
+
+impl MyFrom<u256> for (u64, u64, u64, u64) {
+    fn from(val: u256) -> (u64, u64, u64, u64) {
+        (42, 0, 0, 0)
+    }
+}
+
+// Should not interfere with trait inference
+impl MyFrom<u64> for (u64, u64, u64, u32) {
+    fn from(val: u64) -> (u64, u64, u64, u32) {
+        (42, 0, 0, 0)
+    }
+}
+
+fn main() -> bool {
+    let (a, _b, _c, _d) = u256::min().into();
+
+    assert_eq(a, 42);
+    
+    true
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/test.toml
new file mode 100644
index 00000000000..a4d4f4bade7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_inference/test.toml
@@ -0,0 +1,5 @@
+category = "run"
+expected_result = { action = "return", value = 1 }
+expected_result_new_encoding = { action = "return_data", value = "01" }
+validate_abi = false
+expected_warnings = 3
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_ascription_disambiguate/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_ascription_disambiguate/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_ascription_disambiguate/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_ascription_disambiguate/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_generic_qualified/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_generic_qualified/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_generic_qualified/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_generic_qualified/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_qualified/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_qualified/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_qualified/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/trait_method_qualified/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_access/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_access/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_access/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_access/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_desugaring/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_desugaring/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_desugaring/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_desugaring/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_field_reassignment/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_field_reassignment/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_field_reassignment/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_field_reassignment/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_in_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_in_struct/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_in_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_in_struct/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_indexing/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_indexing/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_indexing/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_indexing/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_single_element/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_single_element/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_single_element/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_single_element/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_trait/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_trait/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_trait/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_trait/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_types/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_types/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_types/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/tuple_types/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/Forc.lock
new file mode 100644
index 00000000000..e5570689316
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "alias"
+source = "path+from-root-DE984AFD05391BAA"
+
+[[package]]
+name = "use-alias"
+source = "member"
+dependencies = ["alias"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/Forc.toml
new file mode 100644
index 00000000000..a0d6afeeff2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/Forc.toml
@@ -0,0 +1,6 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "type_alias_basic"
+implicit-std = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/src/main.sw
new file mode 100644
index 00000000000..fa400cbfbc4
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_basic/src/main.sw
@@ -0,0 +1,4 @@
+library;
+
+struct S {}
+pub type Alias = S;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/Forc.lock
new file mode 100644
index 00000000000..69e0c1abf7b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "type_alias_basic"
+source = "path+from-root-05B061D32AED907C"
+
+[[package]]
+name = "type_alias_from_dependency"
+source = "member"
+dependencies = ["type_alias_basic"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/Forc.toml
new file mode 100644
index 00000000000..82ceffc153f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "type_alias_from_dependency"
+implicit-std = false
+
+[dependencies]
+type_alias_basic = { path = "../type_alias_basic" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/src/main.sw
new file mode 100644
index 00000000000..92e8e146129
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/src/main.sw
@@ -0,0 +1,7 @@
+library;
+
+use type_alias_basic::*;
+
+fn foo() {
+    let z = type_alias_basic::Alias { };
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/test.toml
new file mode 100644
index 00000000000..848f61f7cd7
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_alias_from_dependency/test.toml
@@ -0,0 +1,3 @@
+category = "compile"
+validate_abi = false
+expected_warnings = 2
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/Forc.lock
new file mode 100644
index 00000000000..c6f5f7c1b5c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-9D1294DAC07670CA"
+
+[[package]]
+name = "type_inference_propagation_of_type_constraints"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/Forc.toml
new file mode 100644
index 00000000000..c3320e028d2
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+name = "type_inference_propagation_of_type_constraints"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/src/main.sw
new file mode 100644
index 00000000000..4d2413c6d49
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/src/main.sw
@@ -0,0 +1,64 @@
+// This tests proves that https://github.com/FuelLabs/sway/issues/6379 is fixed.
+
+script;
+
+trait Build {
+    fn build() -> Self;
+}
+
+fn produce<T>() -> T where T: Build {
+    T::build()
+}
+
+impl Build for u8 {
+    fn build() -> Self {
+        7
+    }
+}
+
+impl Build for u32 {
+    fn build() -> Self {
+        31
+    }
+}
+
+impl Build for u64 {
+    fn build() -> Self {
+        63
+    }
+}
+
+fn consume_u8(a: u8) -> u8 {
+    a
+}
+
+fn consume_u32(a: u32) -> u32 {
+    a
+}
+
+fn consume_u64(a: u64) -> u64 {
+    a
+}
+
+fn main() -> (u8, u32, u64) {
+    let a = produce_consume_u8();
+    let b = produce_consume_u32();
+    let c = produce_consume_u64();
+
+    (a, b, c)
+}
+
+fn produce_consume_u8() -> u8 {
+    let x = produce();
+    consume_u8(x)
+}
+
+fn produce_consume_u32() -> u32 {
+    let x = produce();
+    consume_u32(x)
+}
+
+fn produce_consume_u64() -> u64 {
+    let x = produce();
+    consume_u64(x)
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/test.toml
new file mode 100644
index 00000000000..17578590d9b
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/type_inference_propagation_of_type_constraints/test.toml
@@ -0,0 +1,4 @@
+category = "run"
+expected_result = { action = "return_data", value = "0700000000000000 000000000000001f 000000000000003f" }
+expected_result_new_encoding = { action = "return_data", value = "07 0000001f 000000000000003f" }
+validate_abi = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath2/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath2/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath2/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath2/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath_with_import/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath_with_import/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath_with_import/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/typeinfo_custom_callpath_with_import/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle.json
index 553441f0024..019b058bf94 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle.json
@@ -7,7 +7,7 @@
         "typeArguments": null
       },
       "name": "SOME_U256",
-      "offset": 108
+      "offset": 72
     }
   ],
   "functions": [
@@ -24,7 +24,7 @@
   ],
   "loggedTypes": [
     {
-      "logId": 0,
+      "logId": "1970142151624111756",
       "loggedType": {
         "name": "",
         "type": 0,
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle_new_encoding.json
index 5158e5e8e61..5b834c3566e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_abi/json_abi_oracle_new_encoding.json
@@ -1,45 +1,34 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    }
+  ],
   "configurables": [
     {
-      "configurableType": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      },
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
       "name": "SOME_U256",
-      "offset": 592
+      "offset": 808
     }
   ],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1970142151624111756",
-      "loggedType": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "logId": "1970142151624111756"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u256",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_operators/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_operators/src/main.sw
index 02304dd3383..f40e41d2873 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_operators/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/u256/u256_operators/src/main.sw
@@ -175,4 +175,10 @@ fn type_inference_numeric_2() -> u256 {
    let mut result = 0;
    result = 3.as_u256();
    result
-}
\ No newline at end of file
+}
+
+#[test]
+fn incorrect_def_modeling() -> u256 {
+    let c: u256 = 1;
+    c % c  // this emits a WQAM instruction
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic_2/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic_2/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic_2/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/unary_not_basic_2/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/unit_type_variants/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/unit_type_variants/json_abi_oracle_new_encoding.json
index 2b1053b6a48..022cfe8ab4c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/unit_type_variants/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/unit_type_variants/json_abi_oracle_new_encoding.json
@@ -1,48 +1,47 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "469b6a3ae1aee813b2c73788d36a1e8dd84089a16afa4d87d726f87eea55a219",
+      "metadataTypeId": 1,
+      "type": "enum E"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "469b6a3ae1aee813b2c73788d36a1e8dd84089a16afa4d87d726f87eea55a219"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "A",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "B",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "C",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "enum E",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "enum E"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/use_absolute_path/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/use_absolute_path/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/use_absolute_path/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/use_absolute_path/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/use_full_path_names/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/use_full_path_names/json_abi_oracle_new_encoding.json
index 90719972265..ea0a762cd2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/use_full_path_names/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/use_full_path_names/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/valid_impurity/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/valid_impurity/json_abi_oracle_new_encoding.json
index 9bcf8ff9976..be319f53762 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/valid_impurity/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/valid_impurity/json_abi_oracle_new_encoding.json
@@ -1,6 +1,12 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -14,21 +20,12 @@
       ],
       "inputs": [],
       "name": "impure_func",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_enums/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_enums/json_abi_oracle_new_encoding.json
index 21c7e4af04d..d59478ab357 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_enums/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_enums/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_functions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_functions/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_functions/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_functions/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_generic_tuple/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_generic_tuple/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_generic_tuple/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_generic_tuple/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_impls/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_impls/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_impls/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_impls/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_methods/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_methods/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_methods/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_methods/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_structs/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_structs/json_abi_oracle_new_encoding.json
index 21c7e4af04d..d59478ab357 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_structs/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_structs/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_traits/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_traits/json_abi_oracle_new_encoding.json
index 21c7e4af04d..d59478ab357 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_traits/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/where_clause_traits/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/src/main.sw
index 71462419e00..adb7cf187ae 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/while_loops/src/main.sw
@@ -11,7 +11,7 @@ fn main() -> bool {
     // test early exit from loop with manual "break" (by invalidating the condition):
     let mut counter_2 = 0;
     let mut counter_3 = 0;
-    while counter_2 < 10 {
+    while counter_2 < 10 && 1 < 2 {
         if counter_2 == 3 {
             // ensure that condition is now invalid:
             counter_2 = 10;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/zero_field_types/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/zero_field_types/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/zero_field_types/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/zero_field_types/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/src/main.sw
deleted file mode 100644
index 294bca5abeb..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/src/main.sw
+++ /dev/null
@@ -1,3 +0,0 @@
-script;
-
-fn main() -> u64 { 42 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw
index 0cb408413d2..575ca323135 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw
@@ -6,10 +6,15 @@ use std::hash::*;
 #[cfg(experimental_new_encoding = false)]
 const CONTRACT_ID = 0x14ed3cd06c2947248f69d54bfa681fe40d26267be84df7e19e253622b7921bbe;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xad5e3937508bd711011c85aaa1e20a7a1051c723174d30139c87978cd24913cd;
+const CONTRACT_ID = 0xbbda20fb25bdb4b18451501418b06324376c61cb984e75fcbc983fc0a047f85b; // AUTO-CONTRACT-ID ../../test_contracts/array_of_structs_contract --release
+
+fn get_address() -> Option<std::address::Address> {
+    Some(CONTRACT_ID.into())
+}
 
 fn main() -> u64 {
-    let addr = abi(TestContract, CONTRACT_ID);
+    // Test address being a complex expression
+    let addr = abi(TestContract, get_address().unwrap().into());
 
     let input = [Wrapper {
         id: Id {
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw
index 5617072e058..e177370b102 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw
@@ -7,14 +7,14 @@ use std::constants::DEFAULT_SUB_ID;
 use test_fuel_coin_abi::*;
 
 #[cfg(experimental_new_encoding = false)]
-const FUEL_COIN_CONTRACT_ID = 0x4c7b43ef5a097d7cfb87600a4234e33311eeeeb8081e5ea7bb6d9a1f8555c9c4;
+const FUEL_COIN_CONTRACT_ID = 0xec2277ebe007ade87e3d797c3b1e070dcd542d5ef8f038b471f262ef9cebc87c;
 #[cfg(experimental_new_encoding = true)]
-const FUEL_COIN_CONTRACT_ID = 0x1cca4a529aefcae07be80c5b36c0d0928f936836deb742bebffc041f10fbca1b;
+const FUEL_COIN_CONTRACT_ID = 0xf2fecff29038dab2ef571397ea5507359265c9154608e7de36ccbea20ed5c8aa;
 
 #[cfg(experimental_new_encoding = false)]
-const BALANCE_CONTRACT_ID = 0x3120fdd1b99c0c611308aff43a99746cc2c661c69c22aa56331d5f3ce5534ee9;
+const BALANCE_CONTRACT_ID = 0xf6cd545152ac83225e8e7df2efb5c6fa6e37bc9b9e977b5ea8103d28668925df;
 #[cfg(experimental_new_encoding = true)]
-const BALANCE_CONTRACT_ID = 0x9dac51d44d9d053eb2bf1f68bfdbd889ddfdcb470727cda2e1a132f5660f63a6;
+const BALANCE_CONTRACT_ID = 0xebe7a84ed5198e9d7d3e002a571058dc24d56f61f2526ca30328f519528f98eb; // AUTO-CONTRACT-ID ../../test_contracts/balance_test_contract --release
 
 fn main() -> bool {
     let default_gas = 1_000_000_000_000;
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw
index 6a39004fe5d..3afdbe1afc2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw
@@ -3,9 +3,9 @@ script;
 use balance_test_abi::BalanceTest;
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0x3120fdd1b99c0c611308aff43a99746cc2c661c69c22aa56331d5f3ce5534ee9;
+const CONTRACT_ID = 0xf6cd545152ac83225e8e7df2efb5c6fa6e37bc9b9e977b5ea8103d28668925df;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x9dac51d44d9d053eb2bf1f68bfdbd889ddfdcb470727cda2e1a132f5660f63a6;
+const CONTRACT_ID = 0xebe7a84ed5198e9d7d3e002a571058dc24d56f61f2526ca30328f519528f98eb; // AUTO-CONTRACT-ID ../../test_contracts/balance_test_contract --release
 
 fn main() -> bool {
     let balance_test_contract = abi(BalanceTest, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw
index d7668cd1b02..49d7c83bf80 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw
@@ -4,9 +4,9 @@ use abi_with_tuples::{MyContract, Location, Person};
 
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0xb351aff8258ce46d16a71be666dd2b0b09d72243105c51f4423765824e59cac9;
+const CONTRACT_ID = 0xfdc14550c8aee742cd556d0ab7f378b7be0d3b1e6e086c097352e94590d4ed02;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xbc8374cc7bbfa50d3c1f1b6b3a000176272ae875402e6ee55a7ad3bcc3bdde9d;
+const CONTRACT_ID = 0x95bff8249257356f042d500e9f7db1a964ab5739a1b156eafaca3c7a4efc8aaa; // AUTO-CONTRACT-ID ../../test_contracts/abi_with_tuples_contract --release
 
 fn main() -> bool {
     let the_abi = abi(MyContract, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw
index 1fac30f1e41..1f66a607f42 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw
@@ -2,9 +2,9 @@ script;
 use basic_storage_abi::{BasicStorage, Quad};
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0x044ab65bcabeebb73c88d8625ce392224c613cb1dae21ebedaa36bf6db1f5f4e;
+const CONTRACT_ID = 0x94db39f409a31b9f2ebcadeea44378e419208c20de90f5d8e1e33dc1523754cb;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x0550df4fa340d2bbfe638adc3f078cb522153073466bd246c141866f3a07b6e4;
+const CONTRACT_ID = 0xfa786fd319eeb24fe328ceb0e033779ba444962f5534ec4ec24dc6686d3fdc1d; // AUTO-CONTRACT-ID ../../test_contracts/basic_storage --release
 
 fn main() -> u64 {
     let addr = abi(BasicStorage, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw
index 4f8eb269860..a8ae0aaa993 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw
@@ -5,7 +5,7 @@ use contract_with_type_aliases_abi::*;
 #[cfg(experimental_new_encoding = false)]
 const CONTRACT_ID = 0x0cbeb6efe3104b460be769bdc4ea101ebf16ccc16f2d7b667ec3e1c7f5ce35b5;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xd5615006ae0854832fa45a8dbbfe716fba427bc3021946fc80817ca62c153850;
+const CONTRACT_ID = 0x741e73148cf8c2f12b620adb9a15275eeabe703a5c058b0e786117e92024fde2; // AUTO-CONTRACT-ID ../../test_contracts/contract_with_type_aliases --release
 
 fn main() {
     let caller = abi(MyContract, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw
index b9af8e28dd2..f518c022f5b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw
@@ -4,9 +4,9 @@ use increment_abi::Incrementor;
 use dynamic_contract_call::*;
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0x080ca4b6a4661d3cc2138f733cbe54095ce8b910eee73d913c1f43ecad6bf0d2;
+const CONTRACT_ID = 0xd1b4047af7ef111c023ab71069e01dc2abfde487c0a0ce1268e4f447e6c6e4c2;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xe2e720d182b0e443a995ca4bfd1cd44dd5ca8cd4ef393dd2e8f3be509e9f9e34;
+const CONTRACT_ID = 0xc906accda9e1e516ee3122770217d913edca1ae6e3b8bad15c2c1a53ebf5e13e; // AUTO-CONTRACT-ID ../../test_contracts/increment_contract --release
 
 fn main() -> bool {
     let the_abi = abi(Incrementor, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw
index f2079c619d2..c3e736cb17f 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw
@@ -3,9 +3,9 @@ script;
 use storage_enum_abi::*;
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0x0d2d9546e833c166b64a340f5694fa01ca6bb53c3ec681d6c1ade1b9c0a2bf46;
+const CONTRACT_ID = 0xc601d11767195485a6654d566c67774134668863d8c797a8c69e8778fb1f89e9;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xc27baae5959faf586dabd2387ff1332b5af71c0c91c62f31bc4f826d61bd6574;
+const CONTRACT_ID = 0xaa4e990e0796764624423b63c1bb14fdc02918294fab87682c1ee768de745a7e; // AUTO-CONTRACT-ID ../../test_contracts/storage_enum_contract --release
 
 fn main() -> u64 {
     let caller = abi(StorageEnum, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw
index 3a7a089a00d..931e9f010df 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw
@@ -5,7 +5,7 @@ use auth_testing_abi::AuthTesting;
 #[cfg(experimental_new_encoding = false)]
 const CONTRACT_ID = 0xc2eec20491b53aab7232cbd27c31d15417b4e9daf0b89c74cc242ef1295f681f;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x886f83b58dd6af803814b3af3c7f4b2fcdc9b6e99577746996feba8e117fe760;
+const CONTRACT_ID = 0x57892f3d8bd8c58137b35d177a8c03121193d51138ad2218e814af505e90a7f2; // AUTO-CONTRACT-ID ../../test_contracts/auth_testing_contract --release
 
 // should be false in the case of a script
 fn main() -> bool {
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw
index 3586cc6f1bb..0f6ed8007b6 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw
@@ -4,9 +4,9 @@ use core::codec::*;
 use context_testing_abi::*;
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0xc2ec2a4a1b20475700e6793c7f20ad8082294894242b17cf08b5fd7c0d3968ad;
+const CONTRACT_ID = 0x6054c11cda000f5990373a4d61929396165be4dfdd61d5b7bd26da60ab0d8577;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x554f1971d3f43aea4a4802bb0d2d11422a9a1bf33c6e347a6a1d188782a78840;
+const CONTRACT_ID = 0x6c159e40368c6a37b8c479cd63f5462832d5dbdc8d872c4b30edc38e230b7e51; // AUTO-CONTRACT-ID ../../test_contracts/context_testing_contract --release
 
 fn main() -> bool {
     let gas: u64 = u64::max();
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw
index 4e5673b688e..8410b0175e8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw
@@ -3,9 +3,9 @@ script;
 use nested_struct_args_abi::*;
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0x64390eb0cac08d41b6476ad57d711b88846ea35ac800d4fc3c95a551e4039432;
+const CONTRACT_ID = 0xe63d33a1b3a6903808b379f6a41a72fa8a370e8b76626775e7d9d2f9c4c5da40;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x26e66c5eeb71a2d0b8610b6f94ac59922d9b3405de2790bf863a63c46b1b5227;
+const CONTRACT_ID = 0xc26e4f54f9bca811be460d07aaedfa12d46477378573947ae95653affba962be; // AUTO-CONTRACT-ID ../../test_contracts/nested_struct_args_contract --release
 
 fn main() -> bool {
     let caller = abi(NestedStructArgs, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw
index a54a27e54f6..d8f0d656e18 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw
@@ -4,9 +4,9 @@ use storage_access_abi::*;
 use std::hash::*;
 
 #[cfg(experimental_new_encoding = false)]
-const CONTRACT_ID = 0x88732a14508defea37a44d0b0ae9af5c776253215180a1c3288f8d504ebb84db;
+const CONTRACT_ID = 0x3bc28acd66d327b8c1b9624c1fabfc07e9ffa1b5d71c2832c3bfaaf8f4b805e9;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x68d755d3d33d463a1eea52b5a5d38eff4c579f2be440dad02ef6cd8417ce3422;
+const CONTRACT_ID = 0xdc525dd2ea57aa691d4d61acd725ebbefd974eaeb397598ca90c38807dc749bb; // AUTO-CONTRACT-ID ../../test_contracts/storage_access_contract --release
 
 fn main() -> bool {
     let caller = abi(StorageAccess, CONTRACT_ID);
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/resolve_local_items_that_shadow_imports/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/resolve_local_items_that_shadow_imports/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/resolve_local_items_that_shadow_imports/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/resolve_local_items_that_shadow_imports/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/return_in_strange_positions/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/return_in_strange_positions/json_abi_oracle_new_encoding.json
index 068da3305ab..05b0f04b2d3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/return_in_strange_positions/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/return_in_strange_positions/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/Forc.lock
new file mode 100644
index 00000000000..a200f29143a
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "cei_pattern_violation_in_asm_block_mint_burn"
+source = "member"
+dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-61D50B6E7FD9C109"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/Forc.toml
new file mode 100644
index 00000000000..77459e699bf
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+name = "cei_pattern_violation_in_asm_block_mint_burn"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/src/main.sw
new file mode 100644
index 00000000000..225347cbcfe
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/src/main.sw
@@ -0,0 +1,33 @@
+contract;
+
+abi TestAbi {
+    fn mint();
+    fn burn();
+}
+
+const AMOUNT_TO_BURN = 100;
+const ASSET_ID = b256::zero();
+
+impl TestAbi for Contract {
+    fn mint() {
+        let other_contract = abi(TestAbi, 0x3dba0a4455b598b7655a7fb430883d96c9527ef275b49739e7b0ad12f8280eae);
+
+        // interaction
+        other_contract.mint();
+        // effect -- therefore violation of CEI where effect should go before interaction
+        asm(r1: AMOUNT_TO_BURN, r2: ASSET_ID) {
+            mint r1 r2;
+        }
+    }
+
+    fn burn() {
+        let other_contract = abi(TestAbi, 0x3dba0a4455b598b7655a7fb430883d96c9527ef275b49739e7b0ad12f8280eae);
+
+        // interaction
+        other_contract.mint();
+        // effect -- therefore violation of CEI where effect should go before interaction
+        asm(r1: AMOUNT_TO_BURN, r2: ASSET_ID) {
+            burn r1 r2;
+        }
+    }
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/test.toml
new file mode 100644
index 00000000000..1e24d836e35
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_in_asm_block_mint_burn/test.toml
@@ -0,0 +1,5 @@
+category = "compile"
+
+# check: $()Asset burned after external contract interaction in function or method "burn". Consider burning assets before calling another contract
+# check: $()Asset minted after external contract interaction in function or method "mint". Consider minting assets before calling another contract
+expected_warnings = 2
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/address_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/address_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/address_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/address_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/alloc_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/alloc_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/alloc_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/alloc_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq/json_abi_oracle_new_encoding.json
index b50fc6cfd6b..2543df7733e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq/json_abi_oracle_new_encoding.json
@@ -1,242 +1,196 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "ab7cd04e05be58e3fc15d424c2c4a57f824a2a2d97d67252440a3925ebdc1335",
+      "metadataTypeId": 1,
+      "type": "enum std::identity::Identity"
+    },
+    {
+      "concreteTypeId": "f597b637c3b0f588fb8d7086c6f4735caa3122b85f0423b82e489f9bb58e2308",
+      "metadataTypeId": 3,
+      "type": "struct std::address::Address"
+    },
+    {
+      "concreteTypeId": "745e252e80bec590efc3999ae943f07ccea4d5b45b00bb6575499b64abdd3322",
+      "metadataTypeId": 4,
+      "type": "struct std::b512::B512"
+    },
+    {
+      "concreteTypeId": "cdd87b7d12fe505416570c294c884bca819364863efe3bf539245fa18515fbbb",
+      "metadataTypeId": 5,
+      "type": "struct std::bytes::Bytes"
+    },
+    {
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "metadataTypeId": 7,
+      "type": "struct std::contract_id::ContractId"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 12,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     },
     {
-      "logId": "15520703124961489725",
-      "loggedType": {
-        "name": "",
-        "type": 11,
-        "typeArguments": null
-      }
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "logId": "15520703124961489725"
     },
     {
-      "logId": "2992671284987479467",
-      "loggedType": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      }
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "logId": "2992671284987479467"
     },
     {
-      "logId": "14454674236531057292",
-      "loggedType": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      }
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "logId": "14454674236531057292"
     },
     {
-      "logId": "8961848586872524460",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "logId": "8961848586872524460"
     },
     {
-      "logId": "17696813611398264200",
-      "loggedType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": []
-      }
+      "concreteTypeId": "f597b637c3b0f588fb8d7086c6f4735caa3122b85f0423b82e489f9bb58e2308",
+      "logId": "17696813611398264200"
     },
     {
-      "logId": "3008693953818743129",
-      "loggedType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": []
-      }
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "logId": "3008693953818743129"
     },
     {
-      "logId": "14832741149864513620",
-      "loggedType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": []
-      }
+      "concreteTypeId": "cdd87b7d12fe505416570c294c884bca819364863efe3bf539245fa18515fbbb",
+      "logId": "14832741149864513620"
     },
     {
-      "logId": "8385180437869151632",
-      "loggedType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      }
+      "concreteTypeId": "745e252e80bec590efc3999ae943f07ccea4d5b45b00bb6575499b64abdd3322",
+      "logId": "8385180437869151632"
     },
     {
-      "logId": "12356980511120185571",
-      "loggedType": {
-        "name": "",
-        "type": 3,
-        "typeArguments": []
-      }
+      "concreteTypeId": "ab7cd04e05be58e3fc15d424c2c4a57f824a2a2d97d67252440a3925ebdc1335",
+      "logId": "12356980511120185571"
     }
   ],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "[_; 2]",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "[_; 2]"
     },
     {
       "components": [
         {
           "name": "Address",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 3
         },
         {
           "name": "ContractId",
-          "type": 9,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "enum std::identity::Identity",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "enum std::identity::Identity"
     },
     {
-      "components": null,
-      "type": "raw untyped ptr",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "raw untyped ptr"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "struct std::address::Address",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "struct std::address::Address"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct std::b512::B512",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "struct std::b512::B512"
     },
     {
       "components": [
         {
           "name": "buf",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 6
         },
         {
           "name": "len",
-          "type": 12,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct std::bytes::Bytes",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "struct std::bytes::Bytes"
     },
     {
       "components": [
         {
           "name": "ptr",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 2
         },
         {
           "name": "cap",
-          "type": 12,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct std::bytes::RawBytes",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "struct std::bytes::RawBytes"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "struct std::contract_id::ContractId",
-      "typeId": 9,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 10,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 11,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 12,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 13,
-      "typeParameters": null
+      "metadataTypeId": 7,
+      "type": "struct std::contract_id::ContractId"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq_revert/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq_revert/json_abi_oracle_new_encoding.json
index 17f3d600e0d..bf5debeec20 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq_revert/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_eq_revert/json_abi_oracle_new_encoding.json
@@ -1,41 +1,32 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne/json_abi_oracle_new_encoding.json
index b50fc6cfd6b..2543df7733e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne/json_abi_oracle_new_encoding.json
@@ -1,242 +1,196 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "ab7cd04e05be58e3fc15d424c2c4a57f824a2a2d97d67252440a3925ebdc1335",
+      "metadataTypeId": 1,
+      "type": "enum std::identity::Identity"
+    },
+    {
+      "concreteTypeId": "f597b637c3b0f588fb8d7086c6f4735caa3122b85f0423b82e489f9bb58e2308",
+      "metadataTypeId": 3,
+      "type": "struct std::address::Address"
+    },
+    {
+      "concreteTypeId": "745e252e80bec590efc3999ae943f07ccea4d5b45b00bb6575499b64abdd3322",
+      "metadataTypeId": 4,
+      "type": "struct std::b512::B512"
+    },
+    {
+      "concreteTypeId": "cdd87b7d12fe505416570c294c884bca819364863efe3bf539245fa18515fbbb",
+      "metadataTypeId": 5,
+      "type": "struct std::bytes::Bytes"
+    },
+    {
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "metadataTypeId": 7,
+      "type": "struct std::contract_id::ContractId"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 12,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     },
     {
-      "logId": "15520703124961489725",
-      "loggedType": {
-        "name": "",
-        "type": 11,
-        "typeArguments": null
-      }
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "logId": "15520703124961489725"
     },
     {
-      "logId": "2992671284987479467",
-      "loggedType": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      }
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "logId": "2992671284987479467"
     },
     {
-      "logId": "14454674236531057292",
-      "loggedType": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      }
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "logId": "14454674236531057292"
     },
     {
-      "logId": "8961848586872524460",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "logId": "8961848586872524460"
     },
     {
-      "logId": "17696813611398264200",
-      "loggedType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": []
-      }
+      "concreteTypeId": "f597b637c3b0f588fb8d7086c6f4735caa3122b85f0423b82e489f9bb58e2308",
+      "logId": "17696813611398264200"
     },
     {
-      "logId": "3008693953818743129",
-      "loggedType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": []
-      }
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "logId": "3008693953818743129"
     },
     {
-      "logId": "14832741149864513620",
-      "loggedType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": []
-      }
+      "concreteTypeId": "cdd87b7d12fe505416570c294c884bca819364863efe3bf539245fa18515fbbb",
+      "logId": "14832741149864513620"
     },
     {
-      "logId": "8385180437869151632",
-      "loggedType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      }
+      "concreteTypeId": "745e252e80bec590efc3999ae943f07ccea4d5b45b00bb6575499b64abdd3322",
+      "logId": "8385180437869151632"
     },
     {
-      "logId": "12356980511120185571",
-      "loggedType": {
-        "name": "",
-        "type": 3,
-        "typeArguments": []
-      }
+      "concreteTypeId": "ab7cd04e05be58e3fc15d424c2c4a57f824a2a2d97d67252440a3925ebdc1335",
+      "logId": "12356980511120185571"
     }
   ],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "[_; 2]",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "[_; 2]"
     },
     {
       "components": [
         {
           "name": "Address",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 3
         },
         {
           "name": "ContractId",
-          "type": 9,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "enum std::identity::Identity",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "enum std::identity::Identity"
     },
     {
-      "components": null,
-      "type": "raw untyped ptr",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "raw untyped ptr"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "struct std::address::Address",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "struct std::address::Address"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct std::b512::B512",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "struct std::b512::B512"
     },
     {
       "components": [
         {
           "name": "buf",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 6
         },
         {
           "name": "len",
-          "type": 12,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct std::bytes::Bytes",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "struct std::bytes::Bytes"
     },
     {
       "components": [
         {
           "name": "ptr",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 2
         },
         {
           "name": "cap",
-          "type": 12,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct std::bytes::RawBytes",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "struct std::bytes::RawBytes"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "struct std::contract_id::ContractId",
-      "typeId": 9,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 10,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 11,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 12,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 13,
-      "typeParameters": null
+      "metadataTypeId": 7,
+      "type": "struct std::contract_id::ContractId"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne_revert/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne_revert/json_abi_oracle_new_encoding.json
index 17f3d600e0d..bf5debeec20 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne_revert/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_ne_revert/json_abi_oracle_new_encoding.json
@@ -1,41 +1,32 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/assert_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_struct_alignment/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_struct_alignment/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_struct_alignment/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_struct_alignment/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/b512_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/block_height/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/block_height/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/block_height/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/block_height/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_type/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_type/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_type/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/contract_id_type/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_custom_type/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_custom_type/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_custom_type/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_custom_type/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_generic/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_generic/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_generic/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/eq_generic/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/ge_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/ge_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/ge_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/ge_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/generic_empty_struct_with_constraint/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/generic_empty_struct_with_constraint/json_abi_oracle_new_encoding.json
index e60dda965d4..aab161b0506 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/generic_empty_struct_with_constraint/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/generic_empty_struct_with_constraint/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/identity_eq/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/identity_eq/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/identity_eq/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/identity_eq/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/intrinsics/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/intrinsics/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/intrinsics/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/intrinsics/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_ptr/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_ptr/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_ptr/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_ptr/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_slice/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_slice/json_abi_oracle_new_encoding.json
index b3a98a8bfc4..ad33ec5b9e4 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_slice/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/raw_slice/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1e1c7c52c1c7a9901681337f8669555f62aac58911332c9ff6b4ea8e73786570",
+      "type": "raw untyped slice"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1e1c7c52c1c7a9901681337f8669555f62aac58911332c9ff6b4ea8e73786570"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "raw untyped slice",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/require/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/require/json_abi_oracle_new_encoding.json
index 3c87c103235..384c6b19008 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/require/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/require/json_abi_oracle_new_encoding.json
@@ -1,77 +1,64 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "aeb05892041dca93eed4135c33da756bc24675f1e2574e9295c337a84a48d456",
+      "metadataTypeId": 1,
+      "type": "struct CustomError"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     },
     {
-      "logId": "12587658342658067091",
-      "loggedType": {
-        "name": "",
-        "type": 2,
-        "typeArguments": []
-      }
+      "concreteTypeId": "aeb05892041dca93eed4135c33da756bc24675f1e2574e9295c337a84a48d456",
+      "logId": "12587658342658067091"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 0,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
-      "components": null,
-      "type": "bool",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "b256"
     },
     {
       "components": [
         {
           "name": "val_1",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         },
         {
           "name": "val_2",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "val_3",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct CustomError",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "struct CustomError"
     }
-  ]
+  ],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/result/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/result/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/result/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/result/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/sha256/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/sha256/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/sha256/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/sha256/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_div_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_div_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_div_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_div_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/src/main.sw
index 7d9aace3432..aa017641744 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_log_test/src/main.sw
@@ -12,12 +12,12 @@ fn main() -> bool {
     let u_128_8: U128 = U128::from((0, 8));
     let u_128_9: U128 = U128::from((0, 9));
     let u_128_10: U128 = U128::from((0, 10));
-    let u_128_21: U128 = U128::from((0, 21));
+    let u_128_20: U128 = U128::from((0, 20));
     let u_128_42: U128 = U128::from((0, 42));
     let u_128_64: U128 = U128::from((0, 64));
     let u_128_100: U128 = U128::from((0, 100));
     let u_128_127: U128 = U128::from((0, 127));
-    let u_128_max_div_2: U128 = U128::from((1, 0));
+    let u64_max_times_two: U128 = U128::from((1, 0));
     let u_128_max: U128 = U128::max();
 
 
@@ -29,8 +29,8 @@ fn main() -> bool {
     assert(u_128_100.log(u_128_9) == u_128_2);
     assert(u_128_max.log(u_128_2) == u_128_127);
     assert(u_128_max.log(u_128_9) == u_128_42);
-    assert(u_128_max_div_2.log(u_128_2) == u_128_64);
-    assert(u_128_max_div_2.log(u_128_9) == u_128_21);
+    assert(u64_max_times_two.log(u_128_2) == u_128_64);
+    assert(u64_max_times_two.log(u_128_9) == u_128_20);
 
     true
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_mul_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_mul_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_mul_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_mul_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_root_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_root_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_root_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_root_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_test/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_test/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_test/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/u128_test/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/json_abi_oracle_new_encoding.json
index b89d516ddd1..668a88f2e07 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "script",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/Forc.lock
new file mode 100644
index 00000000000..c1d37e27c86
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-9B828159C14C020E"
+
+[[package]]
+name = "std"
+source = "path+from-root-9B828159C14C020E"
+dependencies = ["core"]
+
+[[package]]
+name = "vec_byte_remove"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/Forc.toml
new file mode 100644
index 00000000000..89b82cfa4c6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "vec_byte_remove"
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/src/main.sw
new file mode 100644
index 00000000000..2d8f5b65eca
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/src/main.sw
@@ -0,0 +1,22 @@
+script;
+
+use std::bytes::Bytes;
+
+fn main() -> u64 {
+   1
+}
+
+#[test]
+fn bytes_remove_oob_read() -> u8 {
+  let mut a = Bytes::with_capacity(1);
+  a.push(1);
+  a.remove(0)
+}
+
+#[test]
+fn vec_remove_oob_read() -> u64 {
+  let mut a = Vec::<u64>::with_capacity(2);
+  a.push(1);
+  a.push(2);
+  a.remove(0)
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/test.toml
new file mode 100644
index 00000000000..0f3f6d7e866
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_byte_remove/test.toml
@@ -0,0 +1 @@
+category = "unit_tests_pass"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/superabi/json_abi_oracle_new_encoding.json
index 634a41c163c..2ddcfc0101a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/superabi/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi/json_abi_oracle_new_encoding.json
@@ -1,36 +1,29 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "super_abi_method",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "abi_method",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond/json_abi_oracle_new_encoding.json
index fa8f6e44880..59b99c5020b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond/json_abi_oracle_new_encoding.json
@@ -1,56 +1,41 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "top",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "left",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "right",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "bottom",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond_impl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond_impl/json_abi_oracle_new_encoding.json
index fa8f6e44880..59b99c5020b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond_impl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_diamond_impl/json_abi_oracle_new_encoding.json
@@ -1,56 +1,41 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "top",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "left",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "right",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "bottom",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/Forc.lock
new file mode 100644
index 00000000000..1c445d4c5e1
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-6ECA11F8A7EF18BC"
+
+[[package]]
+name = "std"
+source = "path+from-root-6ECA11F8A7EF18BC"
+dependencies = ["core"]
+
+[[package]]
+name = "superabi_supertrait_external_call"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/Forc.toml
similarity index 80%
rename from test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/Forc.toml
index 17447f01b1e..723c669a7ed 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/raw_slice_ret/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/Forc.toml
@@ -1,8 +1,8 @@
 [project]
+name = "superabi_supertrait_external_call"
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "raw_slice_ret"
 
 [dependencies]
-std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
+std = { path = "../../../reduced_std_libs/sway-lib-std-assert" }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/json_abi_oracle.json
new file mode 100644
index 00000000000..b9c46c95aa6
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/json_abi_oracle.json
@@ -0,0 +1,35 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "method",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    },
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "method1",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "u64",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/src/main.sw
new file mode 100644
index 00000000000..0651c168897
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/src/main.sw
@@ -0,0 +1,21 @@
+contract;
+
+trait MySuperTrait {
+    fn method() -> u64;
+}
+
+abi MyAbi : MySuperTrait {
+    //fn method() -> u64;
+}
+
+impl MySuperTrait for Contract {
+    fn method() -> u64 { 42 }
+}
+
+impl MyAbi for Contract {}
+
+#[test]
+fn tests() {
+    let caller = abi(MyAbi, CONTRACT_ID);
+    assert(caller.method() == 0xBAD)
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/test.toml
new file mode 100644
index 00000000000..9399805a4c5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_external_call/test.toml
@@ -0,0 +1,2 @@
+category = "run"
+expected_result_new_encoding = { action = "revert", value = 123 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_same_methods/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_same_methods/src/main.sw
index e6e24459000..b52eb42a761 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_same_methods/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/superabi_supertrait_same_methods/src/main.sw
@@ -34,5 +34,7 @@ impl MyAbi for Contract {
 fn tests() {
     let caller = abi(MyAbi, CONTRACT_ID);
     assert(caller.method1() == 42);
-    assert(caller.method() == 0xBAD)
+
+    // we disallow calling supertrait methods externally
+    //assert(caller.method() == 0xBAD)
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis/json_abi_oracle_new_encoding.json
index 25fafbe4062..3c91baf4830 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis/json_abi_oracle_new_encoding.json
@@ -1,36 +1,29 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "bar",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "baz",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis_diamond/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis_diamond/json_abi_oracle_new_encoding.json
index 9552e74478e..97235341a02 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis_diamond/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/supertraits_for_abis_diamond/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "abi_method",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_impl_methods_in_json_abi/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_impl_methods_in_json_abi/json_abi_oracle_new_encoding.json
index 5b35f8b4e05..b9405753ac8 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_impl_methods_in_json_abi/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_impl_methods_in_json_abi/json_abi_oracle_new_encoding.json
@@ -1,36 +1,29 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "interface_method",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "impl_method",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_with_tuples/src/some_module.sw b/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_with_tuples/src/some_module.sw
index d48f1ca3af0..8f7f12e489d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_with_tuples/src/some_module.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/abi_with_tuples/src/some_module.sw
@@ -6,6 +6,5 @@ pub struct SomeStruct {
 
 impl SomeStruct {
     pub fn g(self) {
-        
     }
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/test_fuel_coin_abi/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/test_fuel_coin_abi/Forc.lock
index e70b590cf84..e5b03634919 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/test_fuel_coin_abi/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_abis/test_fuel_coin_abi/Forc.lock
@@ -1,11 +1,13 @@
 [[package]]
-name = 'core'
-dependencies = []
+name = "core"
+source = "path+from-root-A7EBB443FC21DBA0"
 
 [[package]]
-name = 'std'
-dependencies = ['core']
+name = "std"
+source = "path+from-root-A7EBB443FC21DBA0"
+dependencies = ["core"]
 
 [[package]]
-name = 'test_fuel_coin_abi'
-dependencies = ['std']
+name = "test_fuel_coin_abi"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/Forc.lock
new file mode 100644
index 00000000000..e85a8258d1c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "abi_with_alias"
+source = "member"
+dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-DE4DCECD674C309C"
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/Forc.toml
similarity index 86%
rename from test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/Forc.toml
index 69bfc30b4af..402ce909bea 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/deprecated_attribute/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/Forc.toml
@@ -1,9 +1,9 @@
 [project]
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
-license = "Apache-2.0"
-name = "deprecated_attribute"
 implicit-std = false
+license = "Apache-2.0"
+name = "abi_with_alias"
 
 [dependencies]
 core = { path = "../../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/json_abi_oracle.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/json_abi_oracle.json
new file mode 100644
index 00000000000..acc54cf39b3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/json_abi_oracle.json
@@ -0,0 +1,63 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+      "metadataTypeId": 0,
+      "type": "(u64, u64)"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+          "name": "arg1"
+        }
+      ],
+      "name": "aliased_tuple",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    },
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+          "name": "_arg1"
+        }
+      ],
+      "name": "tuple",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [
+    {
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": 1
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 1
+        }
+      ],
+      "metadataTypeId": 0,
+      "type": "(_, _)"
+    },
+    {
+      "metadataTypeId": 1,
+      "type": "u64"
+    }
+  ],
+  "programType": "contract",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/json_abi_oracle_new_encoding.json
new file mode 100644
index 00000000000..acc54cf39b3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/json_abi_oracle_new_encoding.json
@@ -0,0 +1,63 @@
+{
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+      "metadataTypeId": 0,
+      "type": "(u64, u64)"
+    }
+  ],
+  "configurables": [],
+  "encodingVersion": "1",
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+          "name": "arg1"
+        }
+      ],
+      "name": "aliased_tuple",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    },
+    {
+      "attributes": null,
+      "inputs": [
+        {
+          "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+          "name": "_arg1"
+        }
+      ],
+      "name": "tuple",
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "metadataTypes": [
+    {
+      "components": [
+        {
+          "name": "__tuple_element",
+          "typeId": 1
+        },
+        {
+          "name": "__tuple_element",
+          "typeId": 1
+        }
+      ],
+      "metadataTypeId": 0,
+      "type": "(_, _)"
+    },
+    {
+      "metadataTypeId": 1,
+      "type": "u64"
+    }
+  ],
+  "programType": "contract",
+  "specVersion": "1"
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/src/main.sw
new file mode 100644
index 00000000000..c75439d8e82
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/src/main.sw
@@ -0,0 +1,15 @@
+contract;
+
+type AliasedTuple = (u64, u64);
+
+abi MyContract {
+    fn tuple(arg1: (u64, u64)); // Inline
+    fn aliased_tuple(arg1: AliasedTuple); // Alias
+}
+
+impl MyContract for Contract {
+    fn tuple(_arg1: (u64, u64)) {
+    }
+    fn aliased_tuple(arg1: AliasedTuple) {
+    }
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/test.toml
new file mode 100644
index 00000000000..2bad8b530a0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_alias/test.toml
@@ -0,0 +1,3 @@
+category = "compile"
+validate_abi = true
+expected_warnings = 1
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_generic_types/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_generic_types/json_abi_oracle_new_encoding.json
index 92455dcaf17..8c5867d2d6a 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_generic_types/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_generic_types/json_abi_oracle_new_encoding.json
@@ -1,451 +1,386 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "a1e229302ed2f092752a6bc4fbe66bb9305e0802b1b01ecc5e1d59356702e956",
+      "metadataTypeId": 0,
+      "type": "(str[5], bool)"
+    },
+    {
+      "concreteTypeId": "81342782c917fcfd178741cb2b3a12ea1ebeaa57253fc4ee6700b4d7d6ab32d3",
+      "metadataTypeId": 3,
+      "type": "[b256; 3]"
+    },
+    {
+      "concreteTypeId": "2d25d8a7618f6e2d5d830cf75baedc6b5081b435d08644cc9dc1ff8ceba6e97b",
+      "metadataTypeId": 5,
+      "type": "[struct MyStruct<u64,bool>; 4]"
+    },
+    {
+      "concreteTypeId": "ed705f920eb2c423c81df912430030def10f03218f0a064bfab81b68de71ae21",
+      "type": "str[6]"
+    },
+    {
+      "concreteTypeId": "c03a3a8c7676b8c228bb24c90bf19a6d8ef92aad1dea3c1939fac4181700eb09",
+      "metadataTypeId": 18,
+      "type": "struct MyArrayStruct<u8,u16>",
+      "typeArguments": [
+        "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+        "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
+      ]
+    },
+    {
+      "concreteTypeId": "885e4c283947ed1ad5ef39b71f7b60135e268e96c6f8101eec48528e61b361ae",
+      "metadataTypeId": 19,
+      "type": "struct MyOtherStruct"
+    },
+    {
+      "concreteTypeId": "86969aac37f36f85cea48bd525e5ff2b0e82867977905bc0121d886fa09a09c3",
+      "metadataTypeId": 20,
+      "type": "struct MyStruct<[b256; 3],u8>",
+      "typeArguments": [
+        "81342782c917fcfd178741cb2b3a12ea1ebeaa57253fc4ee6700b4d7d6ab32d3",
+        "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
+      ]
+    },
+    {
+      "concreteTypeId": "034b31a2288dc1bcad6f11d7617f613c1d1ab12b157957279b559b67cccb8136",
+      "metadataTypeId": 21,
+      "type": "struct MyStructWithTuple<struct SomeGenericStruct<u64>,u16,u32>",
+      "typeArguments": [
+        "c241e75899be40c59f0124bdf35f69f22b5e1aa4d79ed70f78689caa5e861c63",
+        "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+        "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
+      ]
+    },
+    {
+      "concreteTypeId": "c241e75899be40c59f0124bdf35f69f22b5e1aa4d79ed70f78689caa5e861c63",
+      "metadataTypeId": 22,
+      "type": "struct SomeGenericStruct<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "_arg1",
-          "type": 22,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 4,
-              "typeArguments": null
-            },
-            {
-              "name": "",
-              "type": 28,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "86969aac37f36f85cea48bd525e5ff2b0e82867977905bc0121d886fa09a09c3",
+          "name": "_arg1"
         },
         {
-          "name": "_arg2",
-          "type": 6,
-          "typeArguments": null
+          "concreteTypeId": "2d25d8a7618f6e2d5d830cf75baedc6b5081b435d08644cc9dc1ff8ceba6e97b",
+          "name": "_arg2"
         },
         {
-          "name": "_arg3",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "a1e229302ed2f092752a6bc4fbe66bb9305e0802b1b01ecc5e1d59356702e956",
+          "name": "_arg3"
         },
         {
-          "name": "_arg4",
-          "type": 21,
-          "typeArguments": null
+          "concreteTypeId": "885e4c283947ed1ad5ef39b71f7b60135e268e96c6f8101eec48528e61b361ae",
+          "name": "_arg4"
         }
       ],
       "name": "complex_function",
-      "output": {
-        "name": "",
-        "type": 19,
-        "typeArguments": null
-      }
+      "output": "ed705f920eb2c423c81df912430030def10f03218f0a064bfab81b68de71ae21"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "_arg",
-          "type": 20,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 28,
-              "typeArguments": null
-            },
-            {
-              "name": "",
-              "type": 25,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "c03a3a8c7676b8c228bb24c90bf19a6d8ef92aad1dea3c1939fac4181700eb09",
+          "name": "_arg"
         }
       ],
       "name": "take_generic_array",
-      "output": {
-        "name": "",
-        "type": 27,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "_arg",
-          "type": 23,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 24,
-              "typeArguments": [
-                {
-                  "name": "",
-                  "type": 27,
-                  "typeArguments": null
-                }
-              ]
-            },
-            {
-              "name": "",
-              "type": 25,
-              "typeArguments": null
-            },
-            {
-              "name": "",
-              "type": 26,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "034b31a2288dc1bcad6f11d7617f613c1d1ab12b157957279b559b67cccb8136",
+          "name": "_arg"
         }
       ],
       "name": "take_generic_struct_containing_tuple",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 18,
-          "typeArguments": null
+          "typeId": 17
         },
         {
           "name": "__tuple_element",
-          "type": 9,
-          "typeArguments": null
+          "typeId": 8
         }
       ],
-      "type": "(_, _)",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 17,
-          "typeArguments": null
+          "typeId": 16
         },
         {
           "name": "__tuple_element",
-          "type": 15,
-          "typeArguments": null
+          "typeId": 14
         }
       ],
-      "type": "(_, _)",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 15,
-          "typeArguments": null
+          "typeId": 14
         },
         {
           "name": "__tuple_element",
-          "type": 16,
-          "typeArguments": null
+          "typeId": 15
         },
         {
           "name": "__tuple_element",
-          "type": 17,
-          "typeArguments": null
+          "typeId": 16
         }
       ],
-      "type": "(_, _, _)",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "(_, _, _)"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "[_; 3]",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "[_; 3]"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 13,
-          "typeArguments": null
+          "typeId": 12
         }
       ],
-      "type": "[_; 3]",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "[_; 3]"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 22,
           "typeArguments": [
             {
               "name": "",
-              "type": 27,
-              "typeArguments": null
+              "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
             },
             {
               "name": "",
-              "type": 9,
-              "typeArguments": null
+              "typeId": 8
             }
-          ]
+          ],
+          "typeId": 20
         }
       ],
-      "type": "[_; 4]",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "[_; 4]"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 22,
           "typeArguments": [
             {
               "name": "",
-              "type": 13,
-              "typeArguments": null
+              "typeId": 12
             },
             {
               "name": "",
-              "type": 14,
-              "typeArguments": null
+              "typeId": 13
             }
-          ]
+          ],
+          "typeId": 20
         }
       ],
-      "type": "[_; 5]",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "[_; 5]"
     },
     {
-      "components": null,
-      "type": "b256",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 7,
+      "type": "b256"
     },
     {
-      "components": null,
-      "type": "bool",
-      "typeId": 9,
-      "typeParameters": null
+      "metadataTypeId": 8,
+      "type": "bool"
     },
     {
       "components": [
         {
           "name": "Foo",
-          "type": 27,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "Bar",
-          "type": 9,
-          "typeArguments": null
+          "typeId": 8
         }
       ],
+      "metadataTypeId": 9,
       "type": "enum MyEnum",
-      "typeId": 10,
       "typeParameters": [
-        13
+        12
       ]
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 11,
-      "typeParameters": null
+      "metadataTypeId": 10,
+      "type": "generic T"
     },
     {
-      "components": null,
-      "type": "generic U",
-      "typeId": 12,
-      "typeParameters": null
+      "metadataTypeId": 11,
+      "type": "generic U"
     },
     {
-      "components": null,
-      "type": "generic V",
-      "typeId": 13,
-      "typeParameters": null
+      "metadataTypeId": 12,
+      "type": "generic V"
     },
     {
-      "components": null,
-      "type": "generic W",
-      "typeId": 14,
-      "typeParameters": null
+      "metadataTypeId": 13,
+      "type": "generic W"
     },
     {
-      "components": null,
-      "type": "generic X",
-      "typeId": 15,
-      "typeParameters": null
+      "metadataTypeId": 14,
+      "type": "generic X"
     },
     {
-      "components": null,
-      "type": "generic Y",
-      "typeId": 16,
-      "typeParameters": null
+      "metadataTypeId": 15,
+      "type": "generic Y"
     },
     {
-      "components": null,
-      "type": "generic Z",
-      "typeId": 17,
-      "typeParameters": null
+      "metadataTypeId": 16,
+      "type": "generic Z"
     },
     {
-      "components": null,
-      "type": "str[5]",
-      "typeId": 18,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[6]",
-      "typeId": 19,
-      "typeParameters": null
+      "metadataTypeId": 17,
+      "type": "str[5]"
     },
     {
       "components": [
         {
           "name": "tim",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 4
         },
         {
           "name": "tam",
-          "type": 7,
-          "typeArguments": null
+          "typeId": 6
         }
       ],
+      "metadataTypeId": 18,
       "type": "struct MyArrayStruct",
-      "typeId": 20,
       "typeParameters": [
-        13,
-        14
+        12,
+        13
       ]
     },
     {
       "components": [
         {
           "name": "bom",
-          "type": 27,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct MyOtherStruct",
-      "typeId": 21,
-      "typeParameters": null
+      "metadataTypeId": 19,
+      "type": "struct MyOtherStruct"
     },
     {
       "components": [
         {
           "name": "bim",
-          "type": 11,
-          "typeArguments": null
+          "typeId": 10
         },
         {
           "name": "bam",
-          "type": 10,
           "typeArguments": [
             {
               "name": "",
-              "type": 27,
-              "typeArguments": null
+              "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
             }
-          ]
+          ],
+          "typeId": 9
         }
       ],
+      "metadataTypeId": 20,
       "type": "struct MyStruct",
-      "typeId": 22,
       "typeParameters": [
-        11,
-        12
+        10,
+        11
       ]
     },
     {
       "components": [
         {
           "name": "tuple1",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 2
         },
         {
           "name": "tuple2",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 1
         }
       ],
+      "metadataTypeId": 21,
       "type": "struct MyStructWithTuple",
-      "typeId": 23,
       "typeParameters": [
+        14,
         15,
-        16,
-        17
+        16
       ]
     },
     {
       "components": [
         {
           "name": "b",
-          "type": 17,
-          "typeArguments": null
+          "typeId": 16
         }
       ],
+      "metadataTypeId": 22,
       "type": "struct SomeGenericStruct",
-      "typeId": 24,
       "typeParameters": [
-        17
+        16
       ]
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 25,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 26,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 27,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 28,
-      "typeParameters": null
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_same_name_types/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_same_name_types/json_abi_oracle_new_encoding.json
index 0a3b91cb7be..2612bacc0d7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_same_name_types/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_same_name_types/json_abi_oracle_new_encoding.json
@@ -1,133 +1,124 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d",
+      "metadataTypeId": 1,
+      "type": "enum std::option::Option<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "ed705f920eb2c423c81df912430030def10f03218f0a064bfab81b68de71ae21",
+      "type": "str[6]"
+    },
+    {
+      "concreteTypeId": "a45846b92d83fc9bce3ae9107300f47b4adc654abc3a42c7bd6395f4ab30a519",
+      "metadataTypeId": 3,
+      "type": "struct dep_1::MyStruct1"
+    },
+    {
+      "concreteTypeId": "871f7c31e4209def536096b47765433990004089691aa2814a497f27040bee45",
+      "metadataTypeId": 5,
+      "type": "struct dep_2::MyStruct2"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "_arg1",
-          "type": 4,
-          "typeArguments": null
+          "concreteTypeId": "a45846b92d83fc9bce3ae9107300f47b4adc654abc3a42c7bd6395f4ab30a519",
+          "name": "_arg1"
         },
         {
-          "name": "_arg2",
-          "type": 6,
-          "typeArguments": null
+          "concreteTypeId": "871f7c31e4209def536096b47765433990004089691aa2814a497f27040bee45",
+          "name": "_arg2"
         },
         {
-          "name": "_arg3",
-          "type": 1,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 8,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d",
+          "name": "_arg3"
         }
       ],
       "name": "function",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "ed705f920eb2c423c81df912430030def10f03218f0a064bfab81b68de71ae21"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "None",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "Some",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
+      "metadataTypeId": 1,
       "type": "enum std::option::Option",
-      "typeId": 1,
       "typeParameters": [
         2
       ]
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[6]",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "generic T"
     },
     {
       "components": [
         {
           "name": "bam",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 4
         }
       ],
-      "type": "struct dep_1::MyStruct1",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "struct dep_1::MyStruct1"
     },
     {
       "components": [
         {
           "name": "bam",
-          "type": 8,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct dep_1::MyStructDuplicated",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "struct dep_1::MyStructDuplicated"
     },
     {
       "components": [
         {
           "name": "bam",
-          "type": 7,
-          "typeArguments": null
+          "typeId": 6
         }
       ],
-      "type": "struct dep_2::MyStruct2",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "struct dep_2::MyStruct2"
     },
     {
       "components": [
         {
           "name": "bam",
-          "type": 8,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct dep_2::MyStructDuplicated",
-      "typeId": 7,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "struct dep_2::MyStructDuplicated"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_tuples_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_tuples_contract/json_abi_oracle_new_encoding.json
index 80d8e741055..def96385449 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_tuples_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/abi_with_tuples_contract/json_abi_oracle_new_encoding.json
@@ -1,152 +1,137 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1b2815d813e5e2d01d9a1f161e912b1f43f1eb83c2410a41f5bd5e3cc384377d",
+      "metadataTypeId": 3,
+      "type": "(enum abi_with_tuples::Location, u64)"
+    },
+    {
+      "concreteTypeId": "aa3d290422f6a2c01b8a81c1d5c290096cd31190571b4f102b8e597a658ea64a",
+      "metadataTypeId": 2,
+      "type": "(struct abi_with_tuples::Person, u64)"
+    },
+    {
+      "concreteTypeId": "b826e3d5f69670efb0476cddb17428c7c01752bfbe75f0619995d2957b59e7f5",
+      "metadataTypeId": 1,
+      "type": "(struct abi_with_tuples::some_module::SomeStruct)"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "_param",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "aa3d290422f6a2c01b8a81c1d5c290096cd31190571b4f102b8e597a658ea64a",
+          "name": "_param"
         }
       ],
       "name": "bug1",
-      "output": {
-        "name": "",
-        "type": 4,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "_param",
-          "type": 3,
-          "typeArguments": null
+          "concreteTypeId": "1b2815d813e5e2d01d9a1f161e912b1f43f1eb83c2410a41f5bd5e3cc384377d",
+          "name": "_param"
         }
       ],
       "name": "bug2",
-      "output": {
-        "name": "",
-        "type": 4,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "struct_at_return",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "b826e3d5f69670efb0476cddb17428c7c01752bfbe75f0619995d2957b59e7f5"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 7,
-          "typeArguments": null
+          "typeId": 6
         }
       ],
-      "type": "(_)",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "(_)"
     },
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 6,
-          "typeArguments": null
+          "typeId": 5
         },
         {
           "name": "__tuple_element",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "(_, _)",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 4
         },
         {
           "name": "__tuple_element",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "(_, _)",
-      "typeId": 3,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "Earth",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "enum abi_with_tuples::Location",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "enum abi_with_tuples::Location"
     },
     {
       "components": [
         {
           "name": "age",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "struct abi_with_tuples::Person",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 5,
+      "type": "struct abi_with_tuples::Person"
     },
     {
       "components": [
         {
           "name": "data",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 7
         }
       ],
-      "type": "struct abi_with_tuples::some_module::SomeStruct",
-      "typeId": 7,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "struct abi_with_tuples::some_module::SomeStruct"
     },
     {
-      "components": null,
-      "type": "u64",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 7,
+      "type": "u64"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/array_of_structs_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/array_of_structs_contract/json_abi_oracle_new_encoding.json
index c86143ac246..900b92717f2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/array_of_structs_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/array_of_structs_contract/json_abi_oracle_new_encoding.json
@@ -1,118 +1,110 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "49fc07a2e561e763cabe6e181708cc45f213801c05244888c1ce2292b0977f88",
+      "metadataTypeId": 1,
+      "type": "[str[3]; 3]"
+    },
+    {
+      "concreteTypeId": "5daee639ca3a655c4eae99c0c1987f7153e50ad7e7cf1fde2633709bf7ed09bd",
+      "metadataTypeId": 0,
+      "type": "[struct array_of_structs_abi::Wrapper; 2]"
+    },
+    {
+      "concreteTypeId": "0a92c8e0f509a2d3a66f68dd50408ce45a1a2596803b0bc983a69b34bd40dad2",
+      "type": "str[3]"
+    },
+    {
+      "concreteTypeId": "ed2e4683365827293d77b21104cd3278cdff5ebcd36bda8544e30c8c42261d27",
+      "metadataTypeId": 3,
+      "type": "struct array_of_structs_abi::Wrapper"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "param",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "5daee639ca3a655c4eae99c0c1987f7153e50ad7e7cf1fde2633709bf7ed09bd",
+          "name": "param"
         }
       ],
       "name": "return_array_of_structs",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "5daee639ca3a655c4eae99c0c1987f7153e50ad7e7cf1fde2633709bf7ed09bd"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "param",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "49fc07a2e561e763cabe6e181708cc45f213801c05244888c1ce2292b0977f88",
+          "name": "param"
         }
       ],
       "name": "return_element_of_array_of_strings",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "0a92c8e0f509a2d3a66f68dd50408ce45a1a2596803b0bc983a69b34bd40dad2"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "param",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "5daee639ca3a655c4eae99c0c1987f7153e50ad7e7cf1fde2633709bf7ed09bd",
+          "name": "param"
         }
       ],
       "name": "return_element_of_array_of_structs",
-      "output": {
-        "name": "",
-        "type": 4,
-        "typeArguments": null
-      }
+      "output": "ed2e4683365827293d77b21104cd3278cdff5ebcd36bda8544e30c8c42261d27"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 3
         }
       ],
-      "type": "[_; 2]",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "[_; 2]"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 2,
-          "typeArguments": null
+          "typeId": "0a92c8e0f509a2d3a66f68dd50408ce45a1a2596803b0bc983a69b34bd40dad2"
         }
       ],
-      "type": "[_; 3]",
-      "typeId": 1,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[3]",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "[_; 3]"
     },
     {
       "components": [
         {
           "name": "number",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 4
         }
       ],
-      "type": "struct array_of_structs_abi::Id",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "struct array_of_structs_abi::Id"
     },
     {
       "components": [
         {
           "name": "id",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
-      "type": "struct array_of_structs_abi::Wrapper",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "struct array_of_structs_abi::Wrapper"
     },
     {
-      "components": null,
-      "type": "u64",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "u64"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/auth_testing_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/auth_testing_contract/json_abi_oracle_new_encoding.json
index 0c8be9e6e1c..68a28651188 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/auth_testing_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/auth_testing_contract/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "returns_gm_one",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/balance_test_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/balance_test_contract/json_abi_oracle_new_encoding.json
index de452a1600d..6b05e8ae081 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/balance_test_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/balance_test_contract/json_abi_oracle_new_encoding.json
@@ -1,26 +1,23 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "get_42",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/json_abi_oracle_new_encoding.json
index 1ac3be1b41d..2f821ed58f1 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/json_abi_oracle_new_encoding.json
@@ -1,6 +1,49 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d",
+      "metadataTypeId": 0,
+      "type": "enum std::option::Option<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "6906df92e2e485dde893b7d719d621b8910422e7c468f99caa5920e6ac19d9c6",
+      "metadataTypeId": 3,
+      "type": "struct basic_storage_abi::Quad"
+    },
+    {
+      "concreteTypeId": "7880d311d30802b48bd6a100a31adb5af17f94bff12daee556d4f02c1ac5b2ff",
+      "metadataTypeId": 5,
+      "type": "struct std::vec::Vec<struct basic_storage_abi::Quad>",
+      "typeArguments": [
+        "6906df92e2e485dde893b7d719d621b8910422e7c468f99caa5920e6ac19d9c6"
+      ]
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -13,23 +56,12 @@
       ],
       "inputs": [
         {
-          "name": "storage_key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "storage_key"
         }
       ],
       "name": "get_u64",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 9,
-            "typeArguments": null
-          }
-        ]
-      }
+      "output": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d"
     },
     {
       "attributes": [
@@ -42,28 +74,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "slots",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "slots"
         }
       ],
       "name": "intrinsic_load_quad",
-      "output": {
-        "name": "",
-        "type": 7,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 5,
-            "typeArguments": null
-          }
-        ]
-      }
+      "output": "7880d311d30802b48bd6a100a31adb5af17f94bff12daee556d4f02c1ac5b2ff"
     },
     {
       "attributes": [
@@ -76,17 +96,12 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         }
       ],
       "name": "intrinsic_load_word",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -99,28 +114,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "values",
-          "type": 7,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 5,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "7880d311d30802b48bd6a100a31adb5af17f94bff12daee556d4f02c1ac5b2ff",
+          "name": "values"
         }
       ],
       "name": "intrinsic_store_quad",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -133,22 +136,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "value",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "value"
         }
       ],
       "name": "intrinsic_store_word",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -161,22 +158,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "value",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "value"
         }
       ],
       "name": "store_u64",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -190,180 +181,117 @@
       ],
       "inputs": [],
       "name": "test_storage_exhaustive",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "14454674236531057292",
-      "loggedType": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      }
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "logId": "14454674236531057292"
     },
     {
-      "logId": "1970142151624111756",
-      "loggedType": {
-        "name": "",
-        "type": 8,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "logId": "1970142151624111756"
     },
     {
-      "logId": "8961848586872524460",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "logId": "8961848586872524460"
     },
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "None",
-          "type": 0,
-          "typeArguments": null
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
         },
         {
           "name": "Some",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 1
         }
       ],
+      "metadataTypeId": 0,
       "type": "enum std::option::Option",
-      "typeId": 2,
       "typeParameters": [
-        3
+        1
       ]
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "generic T"
     },
     {
-      "components": null,
-      "type": "raw untyped ptr",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "raw untyped ptr"
     },
     {
       "components": [
         {
           "name": "v1",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "v2",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "v3",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "v4",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct basic_storage_abi::Quad",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "struct basic_storage_abi::Quad"
     },
     {
       "components": [
         {
           "name": "ptr",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 2
         },
         {
           "name": "cap",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 4,
       "type": "struct std::vec::RawVec",
-      "typeId": 6,
       "typeParameters": [
-        3
+        1
       ]
     },
     {
       "components": [
         {
           "name": "buf",
-          "type": 6,
           "typeArguments": [
             {
               "name": "",
-              "type": 3,
-              "typeArguments": null
+              "typeId": 1
             }
-          ]
+          ],
+          "typeId": 4
         },
         {
           "name": "len",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 5,
       "type": "struct std::vec::Vec",
-      "typeId": 7,
       "typeParameters": [
-        3
+        1
       ]
-    },
-    {
-      "components": null,
-      "type": "u256",
-      "typeId": 8,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 9,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 10,
-      "typeParameters": null
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/src/main.sw
index 261bd8cb0e8..532709bfed7 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/basic_storage/src/main.sw
@@ -303,6 +303,6 @@ fn test_storage() {
 // If these comparisons are done inline just above then it blows out the register allocator due to
 // all the ASM blocks.
 #[inline(never)]
-fn assert_streq<S1, S2>(lhs: S1, rhs: str) {
+fn assert_streq<S1>(lhs: S1, rhs: str) {
     assert(sha256_str_array(lhs) == sha256(rhs));
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/context_testing_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/context_testing_contract/json_abi_oracle_new_encoding.json
index ad4a24595e0..f977048eae3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/context_testing_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/context_testing_contract/json_abi_oracle_new_encoding.json
@@ -1,133 +1,108 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "c0710b6731b1dd59799cf6bef33eee3b3b04a2e40e80a0724090215bbf2ca974",
+      "metadataTypeId": 1,
+      "type": "struct std::asset_id::AssetId"
+    },
+    {
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "metadataTypeId": 2,
+      "type": "struct std::contract_id::ContractId"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "get_amount",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "get_asset_id",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "c0710b6731b1dd59799cf6bef33eee3b3b04a2e40e80a0724090215bbf2ca974"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "asset_id",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "c0710b6731b1dd59799cf6bef33eee3b3b04a2e40e80a0724090215bbf2ca974",
+          "name": "asset_id"
         },
         {
-          "name": "cid",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+          "name": "cid"
         }
       ],
       "name": "get_balance_of_contract",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "get_gas",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "get_global_gas",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": null,
       "inputs": [],
       "name": "get_id",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "asset_id",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "c0710b6731b1dd59799cf6bef33eee3b3b04a2e40e80a0724090215bbf2ca974",
+          "name": "asset_id"
         }
       ],
       "name": "get_this_balance",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": null,
-      "type": "b256",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "b256"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct std::asset_id::AssetId",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "struct std::asset_id::AssetId"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct std::contract_id::ContractId",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "struct std::contract_id::ContractId"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/contract_with_type_aliases/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/contract_with_type_aliases/json_abi_oracle_new_encoding.json
index 48cafb9b68d..e687a917725 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/contract_with_type_aliases/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/contract_with_type_aliases/json_abi_oracle_new_encoding.json
@@ -1,214 +1,202 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "a28cf4bd3deddbee8bde0daa7b4534d37db682c73dc398fd720c75f3775a3df0",
+      "metadataTypeId": 1,
+      "type": "(b256, [enum std::identity::Identity; 2], struct contract_with_type_aliases_abi::IdentityAliasWrapper, struct contract_with_type_aliases_abi::Generic<struct contract_with_type_aliases_abi::IdentityAliasWrapper>, (b256, b256), str[9])"
+    },
+    {
+      "concreteTypeId": "bc42ec26f2a17c5b23fc007d96b96bf35f8949ee156afdd789064210d881f7e0",
+      "metadataTypeId": 0,
+      "type": "(b256, b256)"
+    },
+    {
+      "concreteTypeId": "2771ee6889dff227342d90c5f1ea6019ad8c8de50880048f823e1b926b26c13e",
+      "metadataTypeId": 2,
+      "type": "[enum std::identity::Identity; 2]"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "bc5b9d5b85b9fb6e78bbb779cc67a95e60d6f291cd256a4c7dba66308dc7dfb8",
+      "type": "str[9]"
+    },
+    {
+      "concreteTypeId": "3981e3d30e52d053c35da213685243d8c82ef363f58bfc2d14986c393254c450",
+      "metadataTypeId": 5,
+      "type": "struct contract_with_type_aliases_abi::Generic<struct contract_with_type_aliases_abi::IdentityAliasWrapper>",
+      "typeArguments": [
+        "1567acc73497bb83e04c376e2c8d3997d0207f0b9b8fa17b0192ee62e1c7a60b"
+      ]
+    },
+    {
+      "concreteTypeId": "1567acc73497bb83e04c376e2c8d3997d0207f0b9b8fa17b0192ee62e1c7a60b",
+      "metadataTypeId": 6,
+      "type": "struct contract_with_type_aliases_abi::IdentityAliasWrapper"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "x",
-          "type": 3,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "x"
         },
         {
-          "name": "y",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "2771ee6889dff227342d90c5f1ea6019ad8c8de50880048f823e1b926b26c13e",
+          "name": "y"
         },
         {
-          "name": "z",
-          "type": 8,
-          "typeArguments": null
+          "concreteTypeId": "1567acc73497bb83e04c376e2c8d3997d0207f0b9b8fa17b0192ee62e1c7a60b",
+          "name": "z"
         },
         {
-          "name": "w",
-          "type": 7,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 8,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "3981e3d30e52d053c35da213685243d8c82ef363f58bfc2d14986c393254c450",
+          "name": "w"
         },
         {
-          "name": "u",
-          "type": 0,
-          "typeArguments": null
+          "concreteTypeId": "bc42ec26f2a17c5b23fc007d96b96bf35f8949ee156afdd789064210d881f7e0",
+          "name": "u"
         },
         {
-          "name": "s",
-          "type": 6,
-          "typeArguments": null
+          "concreteTypeId": "bc5b9d5b85b9fb6e78bbb779cc67a95e60d6f291cd256a4c7dba66308dc7dfb8",
+          "name": "s"
         }
       ],
       "name": "foo",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "a28cf4bd3deddbee8bde0daa7b4534d37db682c73dc398fd720c75f3775a3df0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         },
         {
           "name": "__tuple_element",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "(_, _)",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     },
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         },
         {
           "name": "__tuple_element",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         },
         {
           "name": "__tuple_element",
-          "type": 8,
-          "typeArguments": null
+          "typeId": 6
         },
         {
           "name": "__tuple_element",
-          "type": 7,
           "typeArguments": [
             {
               "name": "",
-              "type": 8,
-              "typeArguments": null
+              "typeId": 6
             }
-          ]
+          ],
+          "typeId": 5
         },
         {
           "name": "__tuple_element",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "__tuple_element",
-          "type": 6,
-          "typeArguments": null
+          "typeId": "bc5b9d5b85b9fb6e78bbb779cc67a95e60d6f291cd256a4c7dba66308dc7dfb8"
         }
       ],
-      "type": "(_, _, _, _, _, _)",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "(_, _, _, _, _, _)"
     },
     {
       "components": [
         {
           "name": "__array_element",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 3
         }
       ],
-      "type": "[_; 2]",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "[_; 2]"
     },
     {
       "components": [
         {
           "name": "Address",
-          "type": 9,
-          "typeArguments": null
+          "typeId": 7
         },
         {
           "name": "ContractId",
-          "type": 10,
-          "typeArguments": null
+          "typeId": 8
         }
       ],
-      "type": "enum std::identity::Identity",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "enum std::identity::Identity"
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 5,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[9]",
-      "typeId": 6,
-      "typeParameters": null
+      "metadataTypeId": 4,
+      "type": "generic T"
     },
     {
       "components": [
         {
           "name": "f",
-          "type": 5,
-          "typeArguments": null
+          "typeId": 4
         }
       ],
+      "metadataTypeId": 5,
       "type": "struct contract_with_type_aliases_abi::Generic",
-      "typeId": 7,
       "typeParameters": [
-        5
+        4
       ]
     },
     {
       "components": [
         {
           "name": "i",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 3
         }
       ],
-      "type": "struct contract_with_type_aliases_abi::IdentityAliasWrapper",
-      "typeId": 8,
-      "typeParameters": null
+      "metadataTypeId": 6,
+      "type": "struct contract_with_type_aliases_abi::IdentityAliasWrapper"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "struct std::address::Address",
-      "typeId": 9,
-      "typeParameters": null
+      "metadataTypeId": 7,
+      "type": "struct std::address::Address"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         }
       ],
-      "type": "struct std::contract_id::ContractId",
-      "typeId": 10,
-      "typeParameters": null
+      "metadataTypeId": 8,
+      "type": "struct std::contract_id::ContractId"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/increment_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/increment_contract/json_abi_oracle_new_encoding.json
index c0b6e46f685..edd98a1f3d1 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/increment_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/increment_contract/json_abi_oracle_new_encoding.json
@@ -1,6 +1,20 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d",
+      "metadataTypeId": 1,
+      "type": "enum std::option::Option<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -13,11 +27,7 @@
       ],
       "inputs": [],
       "name": "get",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -31,17 +41,12 @@
       ],
       "inputs": [
         {
-          "name": "increment_by",
-          "type": 3,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "increment_by"
         }
       ],
       "name": "increment",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -55,64 +60,43 @@
       ],
       "inputs": [
         {
-          "name": "initial_value",
-          "type": 1,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 3,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d",
+          "name": "initial_value"
         }
       ],
       "name": "increment_or_not",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "None",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "Some",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
+      "metadataTypeId": 1,
       "type": "enum std::option::Option",
-      "typeId": 1,
       "typeParameters": [
         2
       ]
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "generic T"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/issue_1512_repro/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/issue_1512_repro/json_abi_oracle_new_encoding.json
index 5d70f6008ee..6da9ef90fa3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/issue_1512_repro/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/issue_1512_repro/json_abi_oracle_new_encoding.json
@@ -1,54 +1,52 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0",
+      "metadataTypeId": 0,
+      "type": "(u64, u64)"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "a",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "a"
         },
         {
-          "name": "b",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "b"
         }
       ],
       "name": "multiply_u64",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "41bd1a98f0a59642d8f824c805b798a5f268d1f7d05808eb05c4189c493f1be0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "__tuple_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "__tuple_element",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "(_, _)",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "(_, _)"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/multiple_impl/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/multiple_impl/json_abi_oracle_new_encoding.json
index e8d2e4e28d4..08401781dda 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/multiple_impl/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/multiple_impl/json_abi_oracle_new_encoding.json
@@ -1,41 +1,32 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [],
       "name": "foo",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 1,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/nested_struct_args_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/nested_struct_args_contract/json_abi_oracle_new_encoding.json
index f7a0b9fa15c..874368e84fd 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/nested_struct_args_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/nested_struct_args_contract/json_abi_oracle_new_encoding.json
@@ -1,73 +1,73 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "42ec906f917884c527853724049ec3e303d2de2916baa4aee461cb71433d0b22",
+      "metadataTypeId": 1,
+      "type": "struct nested_struct_args_abi::StructOne"
+    },
+    {
+      "concreteTypeId": "13f26ca88e0921e7c728fb5763d18dfb2cdad4d55629991628dd5d9f986d6242",
+      "metadataTypeId": 2,
+      "type": "struct nested_struct_args_abi::StructTwo"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "input1",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "42ec906f917884c527853724049ec3e303d2de2916baa4aee461cb71433d0b22",
+          "name": "input1"
         },
         {
-          "name": "input2",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "13f26ca88e0921e7c728fb5763d18dfb2cdad4d55629991628dd5d9f986d6242",
+          "name": "input2"
         }
       ],
       "name": "foo",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "foo",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct nested_struct_args_abi::Inner",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "struct nested_struct_args_abi::Inner"
     },
     {
       "components": [
         {
           "name": "inn",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct nested_struct_args_abi::StructOne",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "struct nested_struct_args_abi::StructOne"
     },
     {
       "components": [
         {
           "name": "foo",
-          "type": 3,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct nested_struct_args_abi::StructTwo",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "struct nested_struct_args_abi::StructTwo"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/return_struct/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/return_struct/json_abi_oracle_new_encoding.json
index 5df1d2110b4..7f2920780b5 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/return_struct/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/return_struct/json_abi_oracle_new_encoding.json
@@ -1,6 +1,20 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "37c06f042972ba5bedfdee34c16f38ace7789cdc2a879df80724d91fb6268d03",
+      "metadataTypeId": 1,
+      "type": "enum std::option::Option<struct data_structures::MyStruct>",
+      "typeArguments": [
+        "37837f87e64f16ec63ac8568b452352098ff2a330df38aa21a9d794dfe33e7cc"
+      ]
+    },
+    {
+      "concreteTypeId": "37837f87e64f16ec63ac8568b452352098ff2a330df38aa21a9d794dfe33e7cc",
+      "type": "struct data_structures::MyStruct"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -13,58 +27,38 @@
       ],
       "inputs": [],
       "name": "test_function",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 3,
-            "typeArguments": null
-          }
-        ]
-      }
+      "output": "37c06f042972ba5bedfdee34c16f38ace7789cdc2a879df80724d91fb6268d03"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
+  "metadataTypes": [
     {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "()"
     },
     {
       "components": [
         {
           "name": "None",
-          "type": 0,
-          "typeArguments": null
+          "typeId": 0
         },
         {
           "name": "Some",
-          "type": 2,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
+      "metadataTypeId": 1,
       "type": "enum std::option::Option",
-      "typeId": 1,
       "typeParameters": [
         2
       ]
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": [],
-      "type": "struct data_structures::MyStruct",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "generic T"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_access_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_access_contract/json_abi_oracle_new_encoding.json
index 90c5fa2590e..9a1f9ebd31e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_access_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_access_contract/json_abi_oracle_new_encoding.json
@@ -1,6 +1,55 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "type": "bool"
+    },
+    {
+      "concreteTypeId": "35b24140807b67d1f1675de36775d5d6c62b04f3721f616a9adee739e24c9c15",
+      "metadataTypeId": 0,
+      "type": "enum storage_access_abi::E"
+    },
+    {
+      "concreteTypeId": "893a66eb2f595d7e0cc15e2253da1b6e53fd634ad542b2f1a198a8ae3d8d92b2",
+      "type": "str[40]"
+    },
+    {
+      "concreteTypeId": "427fd62288add8763eb5e0c4facf553d877489a3038b29a8a1045e9a853660f0",
+      "metadataTypeId": 1,
+      "type": "struct storage_access_abi::S"
+    },
+    {
+      "concreteTypeId": "74df8abb4a65a07ec7420c0f167703fc6e26c9e43b8036ffacb89d399f13db73",
+      "metadataTypeId": 2,
+      "type": "struct storage_access_abi::T"
+    },
+    {
+      "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+      "type": "u16"
+    },
+    {
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+      "type": "u32"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    },
+    {
+      "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+      "type": "u8"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -13,11 +62,7 @@
       ],
       "inputs": [],
       "name": "get_boolean",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     },
     {
       "attributes": [
@@ -30,11 +75,7 @@
       ],
       "inputs": [],
       "name": "get_e",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "35b24140807b67d1f1675de36775d5d6c62b04f3721f616a9adee739e24c9c15"
     },
     {
       "attributes": [
@@ -47,11 +88,7 @@
       ],
       "inputs": [],
       "name": "get_e2",
-      "output": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      }
+      "output": "35b24140807b67d1f1675de36775d5d6c62b04f3721f616a9adee739e24c9c15"
     },
     {
       "attributes": [
@@ -64,11 +101,7 @@
       ],
       "inputs": [],
       "name": "get_int16",
-      "output": {
-        "name": "",
-        "type": 7,
-        "typeArguments": null
-      }
+      "output": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
     },
     {
       "attributes": [
@@ -81,11 +114,7 @@
       ],
       "inputs": [],
       "name": "get_int32",
-      "output": {
-        "name": "",
-        "type": 8,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     },
     {
       "attributes": [
@@ -98,11 +127,7 @@
       ],
       "inputs": [],
       "name": "get_int8",
-      "output": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      }
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
     },
     {
       "attributes": [
@@ -115,11 +140,7 @@
       ],
       "inputs": [],
       "name": "get_s",
-      "output": {
-        "name": "",
-        "type": 5,
-        "typeArguments": null
-      }
+      "output": "427fd62288add8763eb5e0c4facf553d877489a3038b29a8a1045e9a853660f0"
     },
     {
       "attributes": [
@@ -132,11 +153,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t",
-      "output": {
-        "name": "",
-        "type": 6,
-        "typeArguments": null
-      }
+      "output": "74df8abb4a65a07ec7420c0f167703fc6e26c9e43b8036ffacb89d399f13db73"
     },
     {
       "attributes": [
@@ -149,11 +166,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_boolean",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "output": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
     },
     {
       "attributes": [
@@ -166,11 +179,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_int16",
-      "output": {
-        "name": "",
-        "type": 7,
-        "typeArguments": null
-      }
+      "output": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
     },
     {
       "attributes": [
@@ -183,11 +192,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_int32",
-      "output": {
-        "name": "",
-        "type": 8,
-        "typeArguments": null
-      }
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
     },
     {
       "attributes": [
@@ -200,11 +205,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_int8",
-      "output": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      }
+      "output": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
     },
     {
       "attributes": [
@@ -217,11 +218,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_x",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -234,11 +231,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_y",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -251,11 +244,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_t_dot_z",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
     },
     {
       "attributes": [
@@ -268,11 +257,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_x",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -285,11 +270,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_y",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -302,11 +283,7 @@
       ],
       "inputs": [],
       "name": "get_s_dot_z",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
     },
     {
       "attributes": [
@@ -319,11 +296,7 @@
       ],
       "inputs": [],
       "name": "get_string",
-      "output": {
-        "name": "",
-        "type": 4,
-        "typeArguments": null
-      }
+      "output": "893a66eb2f595d7e0cc15e2253da1b6e53fd634ad542b2f1a198a8ae3d8d92b2"
     },
     {
       "attributes": [
@@ -336,11 +309,7 @@
       ],
       "inputs": [],
       "name": "get_x",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -353,11 +322,7 @@
       ],
       "inputs": [],
       "name": "get_y",
-      "output": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "output": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
     },
     {
       "attributes": [
@@ -370,17 +335,12 @@
       ],
       "inputs": [
         {
-          "name": "boolean",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+          "name": "boolean"
         }
       ],
       "name": "set_boolean",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -393,17 +353,12 @@
       ],
       "inputs": [
         {
-          "name": "e",
-          "type": 3,
-          "typeArguments": null
+          "concreteTypeId": "35b24140807b67d1f1675de36775d5d6c62b04f3721f616a9adee739e24c9c15",
+          "name": "e"
         }
       ],
       "name": "set_e",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -416,17 +371,12 @@
       ],
       "inputs": [
         {
-          "name": "int16",
-          "type": 7,
-          "typeArguments": null
+          "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+          "name": "int16"
         }
       ],
       "name": "set_int16",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -439,17 +389,12 @@
       ],
       "inputs": [
         {
-          "name": "int32",
-          "type": 8,
-          "typeArguments": null
+          "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+          "name": "int32"
         }
       ],
       "name": "set_int32",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -462,17 +407,12 @@
       ],
       "inputs": [
         {
-          "name": "int8",
-          "type": 10,
-          "typeArguments": null
+          "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+          "name": "int8"
         }
       ],
       "name": "set_int8",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -485,17 +425,12 @@
       ],
       "inputs": [
         {
-          "name": "s",
-          "type": 5,
-          "typeArguments": null
+          "concreteTypeId": "427fd62288add8763eb5e0c4facf553d877489a3038b29a8a1045e9a853660f0",
+          "name": "s"
         }
       ],
       "name": "set_s",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -508,17 +443,12 @@
       ],
       "inputs": [
         {
-          "name": "t",
-          "type": 6,
-          "typeArguments": null
+          "concreteTypeId": "74df8abb4a65a07ec7420c0f167703fc6e26c9e43b8036ffacb89d399f13db73",
+          "name": "t"
         }
       ],
       "name": "set_s_dot_t",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -531,17 +461,12 @@
       ],
       "inputs": [
         {
-          "name": "boolean",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+          "name": "boolean"
         }
       ],
       "name": "set_s_dot_t_dot_boolean",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -554,17 +479,12 @@
       ],
       "inputs": [
         {
-          "name": "int16",
-          "type": 7,
-          "typeArguments": null
+          "concreteTypeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef",
+          "name": "int16"
         }
       ],
       "name": "set_s_dot_t_dot_int16",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -577,17 +497,12 @@
       ],
       "inputs": [
         {
-          "name": "int32",
-          "type": 8,
-          "typeArguments": null
+          "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
+          "name": "int32"
         }
       ],
       "name": "set_s_dot_t_dot_int32",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -600,17 +515,12 @@
       ],
       "inputs": [
         {
-          "name": "int8",
-          "type": 10,
-          "typeArguments": null
+          "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
+          "name": "int8"
         }
       ],
       "name": "set_s_dot_t_dot_int8",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -623,17 +533,12 @@
       ],
       "inputs": [
         {
-          "name": "x",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "x"
         }
       ],
       "name": "set_s_dot_t_dot_x",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -646,17 +551,12 @@
       ],
       "inputs": [
         {
-          "name": "y",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "y"
         }
       ],
       "name": "set_s_dot_t_dot_y",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -669,17 +569,12 @@
       ],
       "inputs": [
         {
-          "name": "z",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "z"
         }
       ],
       "name": "set_s_dot_t_dot_z",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -692,17 +587,12 @@
       ],
       "inputs": [
         {
-          "name": "x",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "x"
         }
       ],
       "name": "set_s_dot_x",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -715,17 +605,12 @@
       ],
       "inputs": [
         {
-          "name": "y",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "y"
         }
       ],
       "name": "set_s_dot_y",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -738,17 +623,12 @@
       ],
       "inputs": [
         {
-          "name": "z",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "z"
         }
       ],
       "name": "set_s_dot_z",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -761,17 +641,12 @@
       ],
       "inputs": [
         {
-          "name": "string",
-          "type": 4,
-          "typeArguments": null
+          "concreteTypeId": "893a66eb2f595d7e0cc15e2253da1b6e53fd634ad542b2f1a198a8ae3d8d92b2",
+          "name": "string"
         }
       ],
       "name": "set_string",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -784,17 +659,12 @@
       ],
       "inputs": [
         {
-          "name": "x",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "x"
         }
       ],
       "name": "set_x",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -807,164 +677,93 @@
       ],
       "inputs": [
         {
-          "name": "y",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "y"
         }
       ],
       "name": "set_y",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "13213829929622723620",
-      "loggedType": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      }
+      "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
+      "logId": "13213829929622723620"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 2,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "A",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "B",
-          "type": 6,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
-      "type": "enum storage_access_abi::E",
-      "typeId": 3,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[40]",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "enum storage_access_abi::E"
     },
     {
       "components": [
         {
           "name": "x",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "y",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "z",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         },
         {
           "name": "t",
-          "type": 6,
-          "typeArguments": null
+          "typeId": 2
         }
       ],
-      "type": "struct storage_access_abi::S",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "struct storage_access_abi::S"
     },
     {
       "components": [
         {
           "name": "x",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "y",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "z",
-          "type": 1,
-          "typeArguments": null
+          "typeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b"
         },
         {
           "name": "boolean",
-          "type": 2,
-          "typeArguments": null
+          "typeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903"
         },
         {
           "name": "int8",
-          "type": 10,
-          "typeArguments": null
+          "typeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b"
         },
         {
           "name": "int16",
-          "type": 7,
-          "typeArguments": null
+          "typeId": "29881aad8730c5ab11d275376323d8e4ff4179aae8ccb6c13fe4902137e162ef"
         },
         {
           "name": "int32",
-          "type": 8,
-          "typeArguments": null
+          "typeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc"
         }
       ],
-      "type": "struct storage_access_abi::T",
-      "typeId": 6,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 7,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 8,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 9,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 10,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "struct storage_access_abi::T"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_enum_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_enum_contract/json_abi_oracle_new_encoding.json
index 5f87ffd5d9a..32bd4e374ca 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_enum_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_enum_contract/json_abi_oracle_new_encoding.json
@@ -1,6 +1,12 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -14,21 +20,12 @@
       ],
       "inputs": [],
       "name": "read_write_enums",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 0,
-      "typeParameters": null
-    }
-  ]
+  "metadataTypes": [],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/json_abi_oracle_new_encoding.json
index 8e817c80160..a7b039e5eeb 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/json_abi_oracle_new_encoding.json
@@ -1,6 +1,45 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "type": "b256"
+    },
+    {
+      "concreteTypeId": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d",
+      "metadataTypeId": 0,
+      "type": "enum std::option::Option<u64>",
+      "typeArguments": [
+        "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
+      ]
+    },
+    {
+      "concreteTypeId": "6906df92e2e485dde893b7d719d621b8910422e7c468f99caa5920e6ac19d9c6",
+      "metadataTypeId": 3,
+      "type": "struct basic_storage_abi::Quad"
+    },
+    {
+      "concreteTypeId": "7880d311d30802b48bd6a100a31adb5af17f94bff12daee556d4f02c1ac5b2ff",
+      "metadataTypeId": 5,
+      "type": "struct std::vec::Vec<struct basic_storage_abi::Quad>",
+      "typeArguments": [
+        "6906df92e2e485dde893b7d719d621b8910422e7c468f99caa5920e6ac19d9c6"
+      ]
+    },
+    {
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "type": "u256"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": [
@@ -13,23 +52,12 @@
       ],
       "inputs": [
         {
-          "name": "storage_key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "storage_key"
         }
       ],
       "name": "get_u64",
-      "output": {
-        "name": "",
-        "type": 2,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 9,
-            "typeArguments": null
-          }
-        ]
-      }
+      "output": "d852149004cc9ec0bbe7dc4e37bffea1d41469b759512b6136f2e865a4c06e7d"
     },
     {
       "attributes": [
@@ -42,28 +70,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "slots",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "slots"
         }
       ],
       "name": "intrinsic_load_quad",
-      "output": {
-        "name": "",
-        "type": 7,
-        "typeArguments": [
-          {
-            "name": "",
-            "type": 5,
-            "typeArguments": null
-          }
-        ]
-      }
+      "output": "7880d311d30802b48bd6a100a31adb5af17f94bff12daee556d4f02c1ac5b2ff"
     },
     {
       "attributes": [
@@ -76,17 +92,12 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         }
       ],
       "name": "intrinsic_load_word",
-      "output": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "output": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
     },
     {
       "attributes": [
@@ -99,28 +110,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "values",
-          "type": 7,
-          "typeArguments": [
-            {
-              "name": "",
-              "type": 5,
-              "typeArguments": null
-            }
-          ]
+          "concreteTypeId": "7880d311d30802b48bd6a100a31adb5af17f94bff12daee556d4f02c1ac5b2ff",
+          "name": "values"
         }
       ],
       "name": "intrinsic_store_quad",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -133,22 +132,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "value",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "value"
         }
       ],
       "name": "intrinsic_store_word",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -161,22 +154,16 @@
       ],
       "inputs": [
         {
-          "name": "key",
-          "type": 1,
-          "typeArguments": null
+          "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+          "name": "key"
         },
         {
-          "name": "value",
-          "type": 9,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "value"
         }
       ],
       "name": "store_u64",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": [
@@ -190,166 +177,113 @@
       ],
       "inputs": [],
       "name": "test_storage_exhaustive",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [
     {
-      "logId": "1515152261580153489",
-      "loggedType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "logId": "1515152261580153489"
     },
     {
-      "logId": "1970142151624111756",
-      "loggedType": {
-        "name": "",
-        "type": 8,
-        "typeArguments": null
-      }
+      "concreteTypeId": "1b5759d94094368cfd443019e7ca5ec4074300e544e5ea993a979f5da627261e",
+      "logId": "1970142151624111756"
     },
     {
-      "logId": "8961848586872524460",
-      "loggedType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      }
+      "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
+      "logId": "8961848586872524460"
     }
   ],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
       "components": [
         {
           "name": "None",
-          "type": 0,
-          "typeArguments": null
+          "typeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
         },
         {
           "name": "Some",
-          "type": 3,
-          "typeArguments": null
+          "typeId": 1
         }
       ],
+      "metadataTypeId": 0,
       "type": "enum std::option::Option",
-      "typeId": 2,
       "typeParameters": [
-        3
+        1
       ]
     },
     {
-      "components": null,
-      "type": "generic T",
-      "typeId": 3,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "generic T"
     },
     {
-      "components": null,
-      "type": "raw untyped ptr",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "raw untyped ptr"
     },
     {
       "components": [
         {
           "name": "v1",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "v2",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "v3",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         },
         {
           "name": "v4",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
-      "type": "struct basic_storage_abi::Quad",
-      "typeId": 5,
-      "typeParameters": null
+      "metadataTypeId": 3,
+      "type": "struct basic_storage_abi::Quad"
     },
     {
       "components": [
         {
           "name": "ptr",
-          "type": 4,
-          "typeArguments": null
+          "typeId": 2
         },
         {
           "name": "cap",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 4,
       "type": "struct std::vec::RawVec",
-      "typeId": 6,
       "typeParameters": [
-        3
+        1
       ]
     },
     {
       "components": [
         {
           "name": "buf",
-          "type": 6,
           "typeArguments": [
             {
               "name": "",
-              "type": 3,
-              "typeArguments": null
+              "typeId": 1
             }
-          ]
+          ],
+          "typeId": 4
         },
         {
           "name": "len",
-          "type": 9,
-          "typeArguments": null
+          "typeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0"
         }
       ],
+      "metadataTypeId": 5,
       "type": "struct std::vec::Vec",
-      "typeId": 7,
       "typeParameters": [
-        3
+        1
       ]
-    },
-    {
-      "components": null,
-      "type": "u256",
-      "typeId": 8,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 9,
-      "typeParameters": null
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/src/main.sw
index 934376a211b..d84c9d9ee3b 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/storage_namespace/src/main.sw
@@ -291,6 +291,6 @@ fn test_storage() {
 // If these comparisons are done inline just above then it blows out the register allocator due to
 // all the ASM blocks.
 #[inline(never)]
-fn assert_streq<S1, S2>(lhs: S1, rhs: str) {
+fn assert_streq<S1>(lhs: S1, rhs: str) {
     assert(sha256_str_array(lhs) == sha256(rhs));
 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/test_fuel_coin_contract/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/test_fuel_coin_contract/json_abi_oracle_new_encoding.json
index 2f17decfa67..09fce104773 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/test_fuel_coin_contract/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/test_fuel_coin_contract/json_abi_oracle_new_encoding.json
@@ -1,110 +1,97 @@
 {
+  "concreteTypes": [
+    {
+      "concreteTypeId": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d",
+      "type": "()"
+    },
+    {
+      "concreteTypeId": "c0710b6731b1dd59799cf6bef33eee3b3b04a2e40e80a0724090215bbf2ca974",
+      "metadataTypeId": 1,
+      "type": "struct std::asset_id::AssetId"
+    },
+    {
+      "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+      "metadataTypeId": 2,
+      "type": "struct std::contract_id::ContractId"
+    },
+    {
+      "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+      "type": "u64"
+    }
+  ],
   "configurables": [],
-  "encoding": "1",
+  "encodingVersion": "1",
   "functions": [
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "burn_amount",
-          "type": 4,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "burn_amount"
         }
       ],
       "name": "burn",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "coins",
-          "type": 4,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "coins"
         },
         {
-          "name": "asset_id",
-          "type": 2,
-          "typeArguments": null
+          "concreteTypeId": "c0710b6731b1dd59799cf6bef33eee3b3b04a2e40e80a0724090215bbf2ca974",
+          "name": "asset_id"
         },
         {
-          "name": "c_id",
-          "type": 3,
-          "typeArguments": null
+          "concreteTypeId": "29c10735d33b5159f0c71ee1dbd17b36a3e69e41f00fab0d42e1bd9f428d8a54",
+          "name": "c_id"
         }
       ],
       "name": "force_transfer",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     },
     {
       "attributes": null,
       "inputs": [
         {
-          "name": "mint_amount",
-          "type": 4,
-          "typeArguments": null
+          "concreteTypeId": "1506e6f44c1d6291cdf46395a8e573276a4fa79e8ace3fc891e092ef32d1b0a0",
+          "name": "mint_amount"
         }
       ],
       "name": "mint",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
+      "output": "2e38e77b22c314a449e91fafed92a43826ac6aa403ae6a8acb6cf58239fbaf5d"
     }
   ],
   "loggedTypes": [],
   "messagesTypes": [],
-  "types": [
-    {
-      "components": [],
-      "type": "()",
-      "typeId": 0,
-      "typeParameters": null
-    },
+  "metadataTypes": [
     {
-      "components": null,
-      "type": "b256",
-      "typeId": 1,
-      "typeParameters": null
+      "metadataTypeId": 0,
+      "type": "b256"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct std::asset_id::AssetId",
-      "typeId": 2,
-      "typeParameters": null
+      "metadataTypeId": 1,
+      "type": "struct std::asset_id::AssetId"
     },
     {
       "components": [
         {
           "name": "bits",
-          "type": 1,
-          "typeArguments": null
+          "typeId": 0
         }
       ],
-      "type": "struct std::contract_id::ContractId",
-      "typeId": 3,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 4,
-      "typeParameters": null
+      "metadataTypeId": 2,
+      "type": "struct std::contract_id::ContractId"
     }
-  ]
+  ],
+  "programType": "contract",
+  "specVersion": "1"
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/Forc.lock
new file mode 100644
index 00000000000..70b69e79183
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-A1A671B3B44F9A9A"
+
+[[package]]
+name = "lib_log_decode"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-A1A671B3B44F9A9A"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/Forc.toml
new file mode 100644
index 00000000000..ec2c43496a9
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"] 
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "lib_log_decode"
+
+[dependencies]
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/src/lib.sw
new file mode 100644
index 00000000000..bd0e79fc596
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/src/lib.sw
@@ -0,0 +1,34 @@
+library;
+
+use std::flags::disable_panic_on_overflow;
+
+#[test]
+fn test_fn() {
+	let a = 10;
+	log(a);
+	let b = 30;
+	log(b);
+	assert_eq(a, 10)
+}
+
+#[test]
+fn math_u16_overflow_mul() {
+    disable_panic_on_overflow();
+    
+    let a = (u16::max() / 2 ) + 1;
+    let b = a * 2;
+
+    log(b);
+    assert(b == 0_u16)
+}
+
+#[test]
+fn math_u32_overflow_mul() {
+    disable_panic_on_overflow();
+    
+    let a = (u32::max() / 2 ) + 1;
+    let b = a * 2;
+    
+    log(b);
+    assert(b == 0_u32)
+}
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/test.toml
new file mode 100644
index 00000000000..5161cc99146
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/lib_log_decode/test.toml
@@ -0,0 +1,3 @@
+category = "unit_tests_pass"
+expected_decoded_test_logs = ["10", "30", "0", "0"]
+experimental_new_encoding = true
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/Forc.lock
new file mode 100644
index 00000000000..7b4c9a13614
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/Forc.lock
@@ -0,0 +1,16 @@
+[[package]]
+name = "core"
+source = "path+from-root-CA019CD48EEC4945"
+
+[[package]]
+name = "memcpyopt"
+source = "member"
+dependencies = [
+    "core",
+    "std",
+]
+
+[[package]]
+name = "std"
+source = "path+from-root-CA019CD48EEC4945"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/Forc.toml
new file mode 100644
index 00000000000..2120b6faeef
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/Forc.toml
@@ -0,0 +1,9 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "memcpyopt"
+
+[dependencies]
+core = { path = "../../../../../../../sway-lib-core" }
+std = { path = "../../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/src/main.sw
new file mode 100644
index 00000000000..a052a5b7735
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/src/main.sw
@@ -0,0 +1,66 @@
+script;
+
+pub fn main() {
+
+}
+
+pub struct S {
+    ptr: raw_ptr,
+}
+
+impl S {
+    #[inline(never)]
+    pub fn new() -> Self {
+        let ptr = asm(size) {
+            movi size i16;
+            aloc size;
+            hp: raw_ptr
+        };
+        S {ptr: ptr}
+    }
+
+    #[inline(never)]
+    pub fn set(self, idx: u64, val: u64) -> () {
+        assert(idx < 2);
+        let ptr = self.ptr.add::<u64>(idx);
+        ptr.write::<u64>(val);
+    }
+
+    #[inline(never)]
+    pub fn get(self, idx: u64) -> u64 {
+        assert(idx < 2);
+        let ptr = self.ptr.add::<u64>(idx);
+        ptr.read::<u64>()
+    }
+}
+
+#[inline(never)]
+fn side_effect(ref mut a: [S;2]) -> u64 {
+    let mut b = S::new();
+    b.set(0,5);
+    b.set(1,6);
+    a[1] = b;
+    1
+}
+
+#[test]
+fn test() -> () {
+    let mut v1 = S::new();
+    let mut v2 = S::new();
+    v1.set(0,1);
+    v1.set(1,2);
+    v2.set(0,3);
+    v2.set(1,4);
+    let mut a: [S;2] = [v1, v2];
+    let b = a[1].get(side_effect(a)); //ir is shown for this line
+    assert(b == 4);
+    ()
+}
+
+#[test]
+fn foo() -> u64 {
+   let mut x = 43;
+   x = x;
+   assert(x == 43);
+   x
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/test.toml
new file mode 100644
index 00000000000..22e04b50660
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/memcpyopt/test.toml
@@ -0,0 +1,2 @@
+category = "unit_tests_pass"
+validate_abi = false
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/Forc.lock
new file mode 100644
index 00000000000..ff4f7f79e7f
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-2988E4B52C5E1B31"
+
+[[package]]
+name = "script_log_decode"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-2988E4B52C5E1B31"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/Forc.toml
similarity index 86%
rename from test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/Forc.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/Forc.toml
index 63d055cdfb9..c8de77afce9 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/Forc.toml
@@ -2,7 +2,7 @@
 authors = ["Fuel Labs <contact@fuel.sh>"] 
 entry = "main.sw"
 license = "Apache-2.0"
-name = "log_decode"
+name = "script_log_decode"
 
 [dependencies]
 std = { path = "../../../../reduced_std_libs/sway-lib-std-assert" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/src/main.sw
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/src/main.sw
rename to test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/src/main.sw
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/test.toml
similarity index 100%
rename from test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/log_decode/test.toml
rename to test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/script_log_decode/test.toml
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/Forc.lock
index 08f181d52d4..e24a80d0de3 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/Forc.lock
@@ -1,23 +1,23 @@
 [[package]]
-name = 'contract_multi_test'
-source = 'member'
-dependencies = ['std']
+name = "contract_multi_test"
+source = "member"
+dependencies = ["std"]
 
 [[package]]
-name = 'core'
-source = 'path+from-root-28E4A5A6A7E567F7'
+name = "core"
+source = "path+from-root-28E4A5A6A7E567F7"
 
 [[package]]
-name = 'lib_multi_test'
-source = 'member'
-dependencies = ['std']
+name = "lib_multi_test"
+source = "member"
+dependencies = ["std"]
 
 [[package]]
-name = 'script_multi_test'
-source = 'member'
-dependencies = ['std']
+name = "script_multi_test"
+source = "member"
+dependencies = ["std"]
 
 [[package]]
-name = 'std'
-source = 'path+from-root-28E4A5A6A7E567F7'
-dependencies = ['core']
+name = "std"
+source = "path+from-root-28E4A5A6A7E567F7"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/Forc.lock
deleted file mode 100644
index cc15549119c..00000000000
--- a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/Forc.lock
+++ /dev/null
@@ -1,13 +0,0 @@
-[[package]]
-name = 'contract_multi_test'
-source = 'member'
-dependencies = ['std']
-
-[[package]]
-name = 'core'
-source = 'path+from-root-28E4A5A6A7E567F7'
-
-[[package]]
-name = 'std'
-source = 'path+from-root-28E4A5A6A7E567F7'
-dependencies = ['core']
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw
index be250d44dcb..61e416f17bd 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw
@@ -17,16 +17,14 @@ fn test_foo() {
 
 #[test(should_revert)]
 fn test_fail() {
-    let contract_id = 0x0e92e0e9e366124ded23d8c8a9f4dfdc4a966c665387d22b1c977a6a9c3b0653;
-    let caller = abi(MyContract, contract_id);
+    let caller = abi(MyContract, CONTRACT_ID);
     let result = caller.test_function {}();
     assert(result == false)
 }
 
 #[test]
 fn test_success() {
-    let contract_id = 0x0e92e0e9e366124ded23d8c8a9f4dfdc4a966c665387d22b1c977a6a9c3b0653;
-    let caller = abi(MyContract, contract_id);
+    let caller = abi(MyContract, CONTRACT_ID);
     let result = caller.test_function {}();
     assert(result == true)
 }
diff --git a/test/src/e2e_vm_tests/utils/.gitignore b/test/src/e2e_vm_tests/utils/.gitignore
new file mode 100644
index 00000000000..77d3844f58c
--- /dev/null
+++ b/test/src/e2e_vm_tests/utils/.gitignore
@@ -0,0 +1,2 @@
+out
+target
diff --git a/test/src/e2e_vm_tests/utils/Forc.toml b/test/src/e2e_vm_tests/utils/Forc.toml
new file mode 100644
index 00000000000..10a6cda5587
--- /dev/null
+++ b/test/src/e2e_vm_tests/utils/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "utils"
+
+[dependencies]
+core = { path = "../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/utils/src/main.sw b/test/src/e2e_vm_tests/utils/src/main.sw
new file mode 100644
index 00000000000..4dcfbf52f28
--- /dev/null
+++ b/test/src/e2e_vm_tests/utils/src/main.sw
@@ -0,0 +1,146 @@
+library;
+
+/// This is only useful for the e2e harness setup, because
+/// no one else knows how to "decode" this into meaningful
+// textual logs.
+pub trait Dbg {
+    fn dbg(self);
+} {
+    fn dbgln(self) {
+        self.dbg();
+        asm(ra: u64::max(), rb: 2) {
+            logd ra rb zero zero;
+        }
+    }
+}
+
+impl Dbg for str {
+    fn dbg(self) {
+        let encoded = encode(self);
+        asm(ra: u64::max(), ptr: encoded.ptr(), len: encoded.len::<u8>()) {
+            logd ra zero ptr len;
+        }
+    }
+}
+
+
+impl Dbg for u64 {
+    fn dbg(self) {
+        let encoded = encode(self);
+        asm(ra: u64::max(), ptr: encoded.ptr(), len: encoded.len::<u8>()) {
+           logd ra one ptr len;
+        }
+    }
+}
+
+pub struct NewLine {}
+
+pub fn new_line() -> NewLine {
+    NewLine { }
+}
+
+impl Dbg for NewLine {
+    fn dbg(self) {
+        asm(ra: u64::max(), rb: 2) {
+            logd ra rb zero zero;
+        }
+    }
+}
+
+impl<A, B> Dbg for (A, B)
+where
+    A: Dbg,
+    B: Dbg,
+{
+    fn dbg(self) {
+        self.0.dbg();
+        self.1.dbg();
+    }
+}
+
+impl<A, B, C> Dbg for (A, B, C)
+where
+    A: Dbg,
+    B: Dbg,
+    C: Dbg,
+{
+    #[allow(dead_code)]
+    fn dbg(self) {
+        self.0.dbg();
+        self.1.dbg();
+        self.2.dbg();
+    }
+}
+
+impl<A, B, C, D> Dbg for (A, B, C, D)
+where
+    A: Dbg,
+    B: Dbg,
+    C: Dbg,
+    D: Dbg
+{
+    fn dbg(self) {
+        self.0.dbg();
+        self.1.dbg();
+        self.2.dbg();
+        self.3.dbg();
+    }
+}
+
+
+impl<A, B, C, D, E> Dbg for (A, B, C, D, E)
+where
+    A: Dbg,
+    B: Dbg,
+    C: Dbg,
+    D: Dbg,
+    E: Dbg,
+{
+    fn dbg(self) {
+        self.0.dbg();
+        self.1.dbg();
+        self.2.dbg();
+        self.3.dbg();
+        self.4.dbg();
+    }
+}
+
+impl<A, B, C, D, E, F> Dbg for (A, B, C, D, E, F)
+where
+    A: Dbg,
+    B: Dbg,
+    C: Dbg,
+    D: Dbg,
+    E: Dbg,
+    F: Dbg,
+{
+    fn dbg(self) {
+        self.0.dbg();
+        self.1.dbg();
+        self.2.dbg();
+        self.3.dbg();
+        self.4.dbg();
+        self.5.dbg();
+    }
+}
+
+impl<A, B, C, D, E, F, G> Dbg for (A, B, C, D, E, F, G)
+where
+    A: Dbg,
+    B: Dbg,
+    C: Dbg,
+    D: Dbg,
+    E: Dbg,
+    F: Dbg,
+    G: Dbg
+{
+    fn dbg(self) {
+        self.0.dbg();
+        self.1.dbg();
+        self.2.dbg();
+        self.3.dbg();
+        self.4.dbg();
+        self.5.dbg();
+        self.6.dbg();
+    }
+}
diff --git a/test/src/in_language_tests/Forc.toml b/test/src/in_language_tests/Forc.toml
index e015fae4ff0..b2f198bf2f7 100644
--- a/test/src/in_language_tests/Forc.toml
+++ b/test/src/in_language_tests/Forc.toml
@@ -16,9 +16,12 @@ members = [
   "test_programs/identity_inline_tests",
   "test_programs/math_inline_tests",
   "test_programs/option_inline_tests",
+  "test_programs/output_inline_tests",
   "test_programs/result_inline_tests",
   "test_programs/revert_inline_tests",
+  "test_programs/storage_key_inline_tests",
   "test_programs/string_inline_tests",
+  "test_programs/tx_inline_tests",
   "test_programs/u128_inline_tests",
   "test_programs/vec_inline_tests",
   "test_programs/array_conversions_b256_inline_tests",
diff --git a/test/src/in_language_tests/test_programs/bytes_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/bytes_inline_tests/src/main.sw
index 3d69727a4a2..65597943ef7 100644
--- a/test/src/in_language_tests/test_programs/bytes_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/bytes_inline_tests/src/main.sw
@@ -713,7 +713,14 @@ fn bytes_append() {
     bytes.append(bytes2);
     assert(bytes.len() == first_length + second_length);
     assert(bytes.capacity() == first_length + first_length);
-    assert(bytes2.is_empty());
+
+    assert(bytes2.len() == second_length);
+    assert(!bytes2.is_empty());
+
+    assert(bytes2.get(0).unwrap() == d);
+    assert(bytes2.get(1).unwrap() == e);
+    assert(bytes2.get(2).unwrap() == f);
+
     let values = [a, b, c, d, e, f];
     let mut i = 0;
     while i < 6 {
@@ -757,7 +764,12 @@ fn bytes_append_to_empty() {
     empty_bytes.append(bytes);
     assert(empty_bytes.len() == bytes_length);
     assert(empty_bytes.capacity() == bytes_original_capacity);
-    assert(bytes.is_empty());
+
+    assert(bytes.len() == bytes_length);
+    assert(!bytes.is_empty());
+    assert(bytes.get(0).unwrap() == a);
+    assert(bytes.get(1).unwrap() == b);
+    assert(bytes.get(2).unwrap() == c);
 
     let values = [a, b, c];
     let mut i = 0;
@@ -767,6 +779,32 @@ fn bytes_append_to_empty() {
     };
 }
 
+fn bytes_append_self() {
+    let (mut bytes, a, b, c) = setup();
+    assert(bytes.len() == 3);
+    assert(bytes.get(0).unwrap() == a);
+    assert(bytes.get(1).unwrap() == b);
+    assert(bytes.get(2).unwrap() == c);
+
+    bytes.append(bytes);
+
+    assert(bytes.len() == 6);
+    assert(bytes.get(0).unwrap() == a);
+    assert(bytes.get(1).unwrap() == b);
+    assert(bytes.get(2).unwrap() == c);
+    assert(bytes.get(3).unwrap() == a);
+    assert(bytes.get(4).unwrap() == b);
+    assert(bytes.get(5).unwrap() == c);
+}
+
+fn bytes_append_empty_self() {
+    let mut empty_bytes = Bytes::new();
+
+    empty_bytes.append(empty_bytes);
+
+    assert(empty_bytes.len() == 0);
+}
+
 #[test()]
 fn bytes_eq() {
     let (mut bytes, _a, _b, _c) = setup();
@@ -888,7 +926,7 @@ fn bytes_from_raw_slice() {
     };
 
     let mut bytes = Bytes::from(slice);
-    assert(bytes.ptr() == slice.ptr());
+    assert(bytes.ptr() != slice.ptr()); // Bytes should own its buffer
     assert(bytes.len() == slice.number_of_bytes());
 }
 
@@ -921,7 +959,7 @@ fn bytes_raw_slice_into() {
 
     let bytes: Bytes = slice.into();
 
-    assert(bytes.ptr() == slice.ptr());
+    assert(bytes.ptr() != slice.ptr()); // Bytes should own its buffer
     assert(bytes.len() == slice.number_of_bytes());
 }
 
diff --git a/test/src/in_language_tests/test_programs/ecr_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/ecr_inline_tests/src/main.sw
index e11471b2cbe..757156d0383 100644
--- a/test/src/in_language_tests/test_programs/ecr_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/ecr_inline_tests/src/main.sw
@@ -2,6 +2,7 @@ library;
 
 use std::{
     b512::B512,
+    bytes::Bytes,
     ecr::{
         ec_recover,
         ec_recover_address,
@@ -106,28 +107,103 @@ fn ecr_ec_recover_address_r1() {
     assert(result_2.is_err());
 }
 
-#[test]
-fn ecr_ed_verify() {
-    let pub_key_1 = 0x314fa58689bbe1da2430517de2d772b384a1c1d2e9cb87e73c6afcf246045b10;
-    let msg_1 = b256::zero();
-    let msg_hash_1 = sha256(msg_1);
+// Calculated with ed25519-dalek in a rust program
 
-    let hi_1 = 0xf38cef9361894be6c6e0eddec28a663d099d7ddff17c8077a1447d7ecb4e6545;
-    let lo_1 = 0xf5084560039486d3462dd65a40c80a74709b2f06d450ffc5dc00345c6b2cdd00;
-    let signature_1: B512 = B512::from((hi_1, lo_1));
-    // A verified public key with signature 
-    let verified_1 = ed_verify(pub_key_1, signature_1, msg_hash_1);
-    assert(verified_1.is_ok());
-    assert(verified_1.unwrap());
+// use ed25519_dalek::ed25519::signature::Signer;
+// use ed25519_dalek::SECRET_KEY_LENGTH;
+// use ed25519_dalek::SigningKey;
 
-    let pub_key_2 = 0x314fa58689bbe1da2430517de2d772b384a1c1d2e9cb87e73c6afcf246045b10;
-    let msg_2 = b256::zero();
-    let msg_hash_2 = sha256(msg_2);
+// fn main() {
+//     let bytes = hex::decode("638aa7abd1acd372c1ab3bc4951d9df3b33eabb2c019bf60a8c1ff2e424adeb67127a92630327cfa3fac37b0dcc969968da0efb18bbbbf498c16966373973b21").unwrap();
+//     let bytes: [u8; 64] = bytes.try_into().unwrap();
+//     let signing_key: SigningKey = SigningKey::from_keypair_bytes(&bytes).unwrap();
 
-    let hi_2 = b256::zero();
-    let lo_2 = 0xf5084560039486d3462dd65a40c80a74709b2f06d450ffc5dc00345c6b2cdd00;
-    let signature_2: B512 = B512::from((hi_2, lo_2));
-    let verified_2 = ed_verify(pub_key_2, signature_2, msg_hash_2);
+//     let keypair_bytes = signing_key.to_keypair_bytes();
+//     let secret_key = &keypair_bytes[..SECRET_KEY_LENGTH];
+//     let public_key = &keypair_bytes[SECRET_KEY_LENGTH..];
+
+//     println!("Secret Key: {}", hex::encode(secret_key));
+//     println!("Public Key: {}", hex::encode(public_key));
+
+
+//     for x in [1, 16, 32, 64] {
+//         let mut bytes = Vec::new();
+
+//         for i in 0..x {
+//             bytes.push(i as u8);
+//         }
 
-    assert(verified_2.is_err());
+//         let bytes: &[u8] = &bytes;
+
+//         let signature = signing_key.sign(bytes);
+//         let signature = signature.to_bytes();
+//         let lo: [u8; 32] = signature[0..32].try_into().unwrap();
+//         let hi: [u8; 32] = signature[32..64].try_into().unwrap();
+
+//         println!("x = {}, ({}, {})", x, hex::encode(lo), hex::encode(hi));
+//     }
+// }
+
+// Secret Key: 638aa7abd1acd372c1ab3bc4951d9df3b33eabb2c019bf60a8c1ff2e424adeb6
+// Public Key: 7127a92630327cfa3fac37b0dcc969968da0efb18bbbbf498c16966373973b21
+// x = 1, (f5a5aafe874a12bf3460b0a31428306a3c0bf148b23c0726add73f149fb4238f, 11fd17bd7e9e64878f1cf680c316df925ff29784798cca9c8b70209f58fc6004)
+// x = 16, (5573fe0bf140c8f1ca1b6b41fd4dc0bfcf92aefc67ab7dfd8aac1c264a66e67f, b47ed5cd8285cc2e8bf4a24a5e923a543278c43630f6e3d3da5a884de4982406)
+// x = 32, (00d8a17c74a926854155f0092fe8c2db55220cff891a38f0ee00e549fec8ba07, f2dda3573b2f03d19eefebf93aa93d4ebca81e2c42de5b0f52d8c957f6390a0b)
+// x = 64, (9a9e7077c905c855c86fb6aea6052f50a2cf29f70205f465d809cb0b81c6503f, fea5d320a5f9d4164b7eca627d3e81293083e7f6682b3b1ebc257459fcf89b08)
+#[test]
+fn ecr_ed_verify() {
+    let pub_key = 0x7127a92630327cfa3fac37b0dcc969968da0efb18bbbbf498c16966373973b21;
+
+    let lens = [1, 16, 32, 64];
+    let sigs = [
+        (
+            0xf5a5aafe874a12bf3460b0a31428306a3c0bf148b23c0726add73f149fb4238f,
+            0x11fd17bd7e9e64878f1cf680c316df925ff29784798cca9c8b70209f58fc6004,
+        ),
+        (
+            0x5573fe0bf140c8f1ca1b6b41fd4dc0bfcf92aefc67ab7dfd8aac1c264a66e67f,
+            0xb47ed5cd8285cc2e8bf4a24a5e923a543278c43630f6e3d3da5a884de4982406,
+        ),
+        (
+            0x00d8a17c74a926854155f0092fe8c2db55220cff891a38f0ee00e549fec8ba07,
+            0xf2dda3573b2f03d19eefebf93aa93d4ebca81e2c42de5b0f52d8c957f6390a0b,
+        ),
+        (
+            0x9a9e7077c905c855c86fb6aea6052f50a2cf29f70205f465d809cb0b81c6503f,
+            0xfea5d320a5f9d4164b7eca627d3e81293083e7f6682b3b1ebc257459fcf89b08,
+        ),
+    ];
+
+    let mut i = 0;
+    while i < 4 {
+        let len = lens[i];
+        let sig = B512::from((sigs[i].0, sigs[i].1));
+
+        let mut msg = Bytes::new();
+        let mut j = 0_u8;
+        while j < len {
+            msg.push(j);
+            j += 1;
+        }
+
+        let verified = ed_verify(pub_key, sig, msg);
+        assert(verified.is_ok());
+        assert(verified.unwrap());
+
+        i += 1;
+    }
+}
+
+#[test]
+fn ecr_ed_verify_fail() {
+    let pub_key = 0x7127a92630327cfa3fac37b0dcc969968da0efb18bbbbf498c16966373973b21;
+    let msg = Bytes::new();
+    let sig = B512::from((
+        0x19d821bfe7da223e53428b72a59e316c6981fcbba63dff89a11f01ce3d33af44,
+        0xb49089aa12883bfffda92f3aadfd9153f654fb235baef6ab7958c6029fa35f0a,
+    ));
+
+    let verified = ed_verify(pub_key, sig, msg);
+    // Should return error for msg len 0
+    assert(verified.is_err());
 }
diff --git a/test/src/in_language_tests/test_programs/flags_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/flags_inline_tests/src/main.sw
index dc8d7dac430..fc345bee0ef 100644
--- a/test/src/in_language_tests/test_programs/flags_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/flags_inline_tests/src/main.sw
@@ -6,6 +6,8 @@ use std::{
         disable_panic_on_unsafe_math,
         enable_panic_on_overflow,
         enable_panic_on_unsafe_math,
+        panic_on_overflow_enabled,
+        panic_on_unsafe_math_enabled,
         set_flags,
     },
     registers::error,
@@ -65,3 +67,27 @@ fn flags_disable_panic_on_unsafe_math_preserving() {
 
     enable_panic_on_unsafe_math();
 }
+
+#[test]
+fn test_panic_on_overflow_enabled() {
+    // Enabled by default
+    assert(panic_on_overflow_enabled());
+
+    disable_panic_on_overflow();
+    assert(!panic_on_overflow_enabled());
+
+    enable_panic_on_overflow();
+    assert(panic_on_overflow_enabled());
+}
+
+#[test]
+fn test_panic_on_unsafe_math_enabled() {
+    // Enabled by default
+    assert(panic_on_unsafe_math_enabled());
+
+    disable_panic_on_unsafe_math();
+    assert(!panic_on_unsafe_math_enabled());
+
+    enable_panic_on_unsafe_math();
+    assert(panic_on_unsafe_math_enabled());
+}
diff --git a/test/src/in_language_tests/test_programs/math_inline_tests/Forc.toml b/test/src/in_language_tests/test_programs/math_inline_tests/Forc.toml
index 6ac992f8d23..c2c187517b7 100644
--- a/test/src/in_language_tests/test_programs/math_inline_tests/Forc.toml
+++ b/test/src/in_language_tests/test_programs/math_inline_tests/Forc.toml
@@ -5,4 +5,5 @@ license = "Apache-2.0"
 name = "math_inline_tests"
 
 [dependencies]
+core = { path = "../../../../../sway-lib-core" }
 std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/in_language_tests/test_programs/math_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/math_inline_tests/src/main.sw
index 02e0cc2458b..c2641d71272 100644
--- a/test/src/in_language_tests/test_programs/math_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/math_inline_tests/src/main.sw
@@ -1,5 +1,7 @@
 library;
 
+use std::{flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}, registers::flags};
+
 #[test]
 fn math_root_u256() {
     let max_u256 = u256::max();
@@ -270,6 +272,7 @@ fn math_log_u8() {
 #[test]
 fn math_log_u256() {
     let max_u256 = u256::max();
+    let prior_flags = flags();
     assert(0x2u256.log(0x2u256) == 0x1u256);
     assert(0x1u256.log(0x3u256) == 0);
     assert(0x8u256.log(0x2u256) == 0x3u256);
@@ -277,6 +280,13 @@ fn math_log_u256() {
     assert(0x64u256.log(0x2u256) == 0x6u256);
     assert(0x64u256.log(0x9u256) == 0x2u256);
     assert(max_u256.log(0x2u256) == 0xffu256);
+    assert(prior_flags == flags());
+
+    let _ = disable_panic_on_unsafe_math();
+    let prior_flags = flags();
+    assert(0x1u256.log(0x1u256) == 0);
+    assert(0x0u256.log(0x3u256) == 0);
+    assert(prior_flags == flags());
 }
 
 #[test]
@@ -367,3 +377,735 @@ fn math_b256_zero() {
     let other_b256 = 0x0000000000000000000000000000000000000000000000000000000000000001;
     assert(!other_b256.is_zero());
 }
+
+#[test]
+fn math_test_parity_u256_log_with_ruint() {
+    // Failure cases found by comparing parity with ruint implementation of U256
+    // https://docs.rs/ruint/latest/src/ruint/log.rs.html#45-89
+    let a = [
+        2, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
+        9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13,
+        14, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+        16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+        17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+        19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21,
+        21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+        22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24,
+        24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26,
+        26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 29, 29, 29,
+        29, 29, 30, 30, 30, 30, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+        32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+        32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+        33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+        34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
+        34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35,
+        35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
+        35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+        36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37,
+        37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+        37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+        38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39,
+        39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
+        39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+        40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43,
+        43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+        43, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
+        44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+        45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
+        46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
+        47, 47, 47, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
+        48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 50, 50, 50,
+        50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 51, 51, 51, 51, 51, 51, 51, 51,
+        51, 51, 51, 51, 51, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 53, 53,
+        53, 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
+        55, 55, 55, 55, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 57, 57,
+        57, 57, 57, 57, 57, 58, 58, 58, 58, 58, 58, 59, 59, 59, 59, 59, 60, 60, 60,
+        60, 61, 61, 61, 62, 62, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 65, 65,
+        65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+        65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+        65, 65, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+        66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+        66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67,
+        67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
+        67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 68,
+        68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+        68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+        68, 68, 68, 68, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+        69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+        69, 69, 69, 69, 69, 69, 69, 69, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
+        70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
+        70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 71, 71, 71, 71, 71, 71, 71, 71,
+        71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
+        71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, 72,
+        72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
+        72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 73, 73, 73, 73, 73,
+        73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+        73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 74, 74, 74, 74, 74,
+        74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74,
+        74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75,
+        75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+        75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 76, 76, 76, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 76, 76, 76, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+        77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+        77, 77, 77, 77, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+        78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 79,
+        79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
+        79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 80, 80, 80, 80, 80, 80, 80,
+        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
+        80, 80, 80, 80, 80, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
+        81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 82, 82, 82, 82,
+        82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82,
+        82, 82, 82, 82, 82, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
+        83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 84, 84, 84, 84, 84, 84,
+        84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+        84, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+        85, 85, 85, 85, 85, 85, 85, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
+        86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 87, 87, 87, 87, 87, 87, 87,
+        87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88,
+        88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
+        90, 90, 90, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+        91, 91, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+        92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+        94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 95, 95,
+        95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 96, 96, 96, 96, 96, 96, 96,
+        96, 96, 96, 96, 96, 96, 96, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+        97, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 99, 99, 99, 99, 99, 99,
+        99, 99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+    ];
+    let b = [
+        3, 3, 5, 6, 7, 3, 6, 7, 3, 7, 3, 3, 9, 10, 11, 12, 13, 14, 15, 3, 10, 11,
+        12, 13, 14, 15, 3, 11, 12, 13, 14, 15, 3, 12, 13, 14, 15, 3, 13, 14, 15, 3,
+        14, 15, 3, 15, 3, 3, 5, 6, 7, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+        28, 29, 30, 31, 3, 5, 6, 7, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+        30, 31, 3, 5, 6, 7, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3,
+        5, 6, 7, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 21, 22,
+        23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 22, 23, 24, 25, 26, 27, 28,
+        29, 30, 31, 3, 5, 6, 7, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 24,
+        25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 25, 26, 27, 28, 29, 30, 31, 3, 6,
+        7, 26, 27, 28, 29, 30, 31, 3, 6, 7, 27, 28, 29, 30, 31, 3, 6, 7, 28, 29, 30,
+        31, 3, 6, 7, 29, 30, 31, 3, 6, 7, 30, 31, 3, 6, 7, 31, 3, 6, 7, 3, 6, 7, 33,
+        34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+        53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 6, 7, 34, 35, 36, 37, 38, 39,
+        40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
+        59, 60, 61, 62, 63, 3, 6, 7, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+        47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 6,
+        7, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+        54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 37, 38, 39, 40, 41, 42, 43,
+        44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+        63, 3, 7, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+        54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 39, 40, 41, 42, 43, 44, 45,
+        46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3,
+        7, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+        58, 59, 60, 61, 62, 63, 3, 7, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 42, 43, 44, 45, 46,
+        47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7,
+        43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+        62, 63, 3, 7, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
+        59, 60, 61, 62, 63, 3, 7, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+        57, 58, 59, 60, 61, 62, 63, 3, 7, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+        56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+        56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+        57, 58, 59, 60, 61, 62, 63, 3, 7, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
+        59, 60, 61, 62, 63, 3, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+        63, 3, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 52, 53, 54,
+        55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+        62, 63, 3, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 55, 56, 57, 58, 59,
+        60, 61, 62, 63, 3, 56, 57, 58, 59, 60, 61, 62, 63, 3, 57, 58, 59, 60, 61,
+        62, 63, 3, 58, 59, 60, 61, 62, 63, 3, 59, 60, 61, 62, 63, 3, 60, 61, 62, 63,
+        3, 61, 62, 63, 3, 62, 63, 3, 63, 3, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15,
+        65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+        84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5,
+        6, 7, 9, 10, 11, 12, 13, 14, 15, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+        77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+        96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 67, 68, 69, 70,
+        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13,
+        14, 15, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+        85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6,
+        7, 9, 10, 11, 12, 13, 14, 15, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+        99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 70, 71, 72, 73, 74, 75, 76,
+        77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+        96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 71, 72, 73, 74,
+        75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+        94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 72, 73,
+        74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+        93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 73,
+        74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+        93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 74,
+        75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+        94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 75, 76,
+        77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+        96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 76, 77, 78, 79,
+        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+        99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 77, 78, 79, 80, 81, 82, 83,
+        84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5,
+        6, 7, 9, 10, 11, 12, 13, 14, 15, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+        89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12,
+        13, 14, 15, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
+        95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 80, 81, 82,
+        83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3,
+        5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+        91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15,
+        82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+        3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+        93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 84, 85,
+        86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10,
+        11, 12, 13, 14, 15, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+        99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 86, 87, 88, 89, 90, 91, 92, 93,
+        94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 87, 88, 89,
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14,
+        15, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11,
+        12, 13, 14, 15, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6,
+        7, 10, 11, 12, 13, 14, 15, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3,
+        5, 6, 7, 10, 11, 12, 13, 14, 15, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+        3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3,
+        5, 6, 7, 10, 11, 12, 13, 14, 15, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6,
+        7, 10, 11, 12, 13, 14, 15, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11,
+        12, 13, 14, 15, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15,
+        96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 97, 98, 99, 100,
+        3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13,
+        14, 15, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 100, 3, 5, 6, 7, 11,
+        12, 13, 14, 15,
+    ];
+    let expected = [
+        0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,
+        0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 2, 0, 2, 2, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 3,
+        1, 1, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 3, 1, 1, 0, 0, 3, 1, 1, 0, 3, 1, 1, 3,
+        1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0,
+        0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 3, 0, 3, 3, 2,
+        2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1,
+        1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2,
+        2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2,
+        2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2,
+        2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+        0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1,
+    ];
+
+    let mut i = 0;
+
+    while i < 1825 {
+        let ai: u64 = a[i];
+        let bi: u64 = b[i];
+        let expected_val: u64 = expected[i];
+
+        let result = u256::from(ai).log(u256::from(bi));
+        assert_eq(result, u256::from(expected_val));
+        i += 1;
+    }
+}
+
+// u256 log invalid operations tests
+#[test(should_revert)]
+fn math_u256_log_fail_base_0() {
+    let result = u256::from(2_u64).log(u256::from(0_u64));
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u256_log_fail_base_1() {
+    let result = u256::from(2_u64).log(u256::from(1_u64));
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u256_log_fail_x_0() {
+    let result = u256::from(0_u64).log(u256::from(2_u64));
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u256_log2_fail_x_0() {
+    let result = u256::from(0_u64).log2();
+    log(result);
+}
+
+// u64 log invalid operations tests
+#[test(should_revert)]
+fn math_u64_log_fail_base_0() {
+    let result = 2_u64.log(0_u64);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u64_log_fail_base_1() {
+    let result = 2_u64.log(1_u64);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u64_log_fail_x_0() {
+    let result = 0_u64.log(2_u64);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u64_log2_fail_x_0() {
+    let result = 0_u64.log2();
+    log(result);
+}
+
+// u32 log invalid operations tests
+#[test(should_revert)]
+fn math_u32_log_fail_base_0() {
+    let result = 2_u32.log(0_u32);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u32_log_fail_base_1() {
+    let result = 2_u32.log(1_u32);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u32_log_fail_x_0() {
+    let result = 0_u32.log(2_u32);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u32_log2_fail_x_0() {
+    let result = 0_u32.log2();
+    log(result);
+}
+
+// u16 log invalid operations tests
+#[test(should_revert)]
+fn math_u16_log_fail_base_0() {
+    let result = 2_u16.log(0_u16);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u16_log_fail_base_1() {
+    let result = 2_u16.log(1_u16);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u16_log_fail_x_0() {
+    let result = 0_u16.log(2_u16);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u16_log2_fail_x_0() {
+    let result = 0_u16.log2();
+    log(result);
+}
+
+// u8 log invalid operations tests
+#[test(should_revert)]
+fn math_u8_log_fail_base_0() {
+    let result = 2_u8.log(0_u8);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u8_log_fail_base_1() {
+    let result = 2_u8.log(1_u8);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u8_log_fail_x_0() {
+    let result = 0_u8.log(2_u8);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_u8_log2_fail_x_0() {
+    let result = 0_u8.log2();
+    log(result);
+}
+
+#[test(should_revert)]
+fn revert_math_u8_pow_overflow() {
+    let result = 2_u8.pow(8);
+    log(result);
+}
+
+// pow overflow tests
+#[test(should_revert)]
+fn revert_math_u16_pow_overflow() {
+    let result = 2_u16.pow(16);
+    log(result);
+}
+
+#[test(should_revert)]
+fn revert_math_u32_pow_overflow() {
+    let result = 2_u32.pow(32);
+    log(result);
+}
+
+#[test(should_revert)]
+fn revert_math_u64_pow_overflow() {
+    let result = 2_u64.pow(64);
+    log(result);
+}
+
+#[test(should_revert)]
+fn revert_math_u256_pow_overflow() {
+    let result = 2.as_u256().pow(256);
+    log(result);
+}
+
+#[test(should_revert)]
+fn math_0th_root_fail() {
+    let res = asm(r1: 100, r2: 0, r3) {
+        mroo r3 r1 r2;
+        r3: u8
+    };
+    log(res);
+}
+
+#[test(should_revert)]
+fn math_u8_overflow_add_revert() {
+    let a = u8::max();
+    let b = a + 1;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u16_overflow_add_revert() {
+    let a = u16::max();
+    let b = a + 1;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u32_overflow_add_revert() {
+    let a = u32::max();
+    let b = a + 1;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u64_overflow_add_revert() {
+    let a = u64::max();
+    let b = a + 1;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u256_overflow_add_revert() {
+    let a = u256::max();
+    let b = a + 1;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u8_overflow_mul_revert() {
+    let a = u8::max();
+    let b = a * 2;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u16_overflow_mul_revert() {
+    let a = u16::max();
+    let b = a * 2;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u32_overflow_mul_revert() {
+    let a = u32::max();
+    let b = a * 2;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u64_overflow_mul_revert() {
+    let a = u64::max();
+    let b = a * 2;
+    log(b);
+}
+
+#[test(should_revert)]
+fn math_u256_overflow_mul_revert() {
+    let a = u256::max();
+    let b = a * 2;
+    log(b);
+}
+
+#[test]
+fn math_u8_overflow_add() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u8::max();
+    let b = a + 1;
+
+    require(b == 0_u8, b);
+
+    let c = a + 2;
+
+    require(c == 1_u8, c);
+
+    let d = a + u8::max();
+
+    require(d == u8::max() - 1, d);
+
+    let e = a + (u8::max() - 1);
+
+    require(e == u8::max() - 2, e);
+}
+
+#[test]
+fn math_u16_overflow_add() {
+    let _ = disable_panic_on_overflow();
+
+    let a: u16 = u16::max();
+    let b: u16 = a + 1;
+
+    require(b == 0_u16, b);
+
+    let c = a + 2;
+
+    require(c == 1_u16, c);
+
+    let d = a + u16::max();
+
+    require(d == u16::max() - 1, d);
+
+    let e = a + (u16::max() - 1);
+
+    require(e == u16::max() - 2, e);
+}
+
+#[test]
+fn math_u32_overflow_add() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u32::max();
+    let b = a + 1;
+
+    require(b == 0_u32, b);
+
+    let c = a + 2;
+
+    require(c == 1_u32, c);
+
+    let d = a + u32::max();
+
+    require(d == u32::max() - 1, d);
+
+    let e = a + (u32::max() - 1);
+
+    require(e == u32::max() - 2, e);
+}
+
+#[test]
+fn math_u64_overflow_add() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u64::max();
+    let b = a + 1;
+
+    require(b == 0_u64, b);
+
+    let c = a + 2;
+
+    require(c == 1_u64, c);
+
+    let d = a + u64::max();
+
+    require(d == u64::max() - 1, d);
+
+    let e = a + (u64::max() - 1);
+
+    require(e == u64::max() - 2, e);
+}
+
+#[test]
+fn math_u256_overflow_add() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u256::max();
+    let b = a + 1;
+
+    require(b == u256::zero(), b);
+
+    let c = a + 2;
+
+    require(c == 1, c);
+
+    let d = a + u256::max();
+
+    require(d == u256::max() - 1, d);
+
+    let e = a + (u256::max() - 1);
+
+    require(e == u256::max() - 2, e);
+}
+
+#[test]
+fn math_u8_overflow_mul() {
+    let _ = disable_panic_on_overflow();
+
+    let a = (u8::max() / 2) + 1;
+    let b = a * 2;
+
+    require(b == 0_u8, b)
+}
+
+#[test]
+fn math_u16_overflow_mul() {
+    let _ = disable_panic_on_overflow();
+
+    let a = (u16::max() / 2) + 1;
+    let b = a * 2;
+
+    require(b == 0_u16, b)
+}
+
+#[test]
+fn math_u32_overflow_mul() {
+    let _ = disable_panic_on_overflow();
+
+    let a = (u32::max() / 2) + 1;
+    let b = a * 2;
+
+    require(b == 0_u32, b)
+}
+
+#[test]
+fn math_u64_overflow_mul() {
+    let _ = disable_panic_on_overflow();
+
+    let a = (u64::max() / 2) + 1;
+    let b = a * 2;
+
+    require(b == 0_u64, b)
+}
+
+#[test]
+fn math_u256_overflow_mul() {
+    let _ = disable_panic_on_overflow();
+
+    let a = (u256::max() / 2) + 1;
+    let b = a * 2;
+
+    require(b == 0.as_u256(), b);
+}
+
+#[test]
+fn math_u8_overflow_pow() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u8::max();
+    let b = a.pow(2);
+
+    require(b == 0_u8, b);
+}
+
+#[test]
+fn math_u16_overflow_pow() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u16::max();
+    let b = a.pow(2);
+
+    require(b == 0_u16, b);
+}
+
+#[test]
+fn math_u32_overflow_pow() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u32::max();
+    let b = a.pow(2);
+
+    require(b == 0_u32, b);
+}
+
+#[test]
+fn math_u64_overflow_pow() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u64::max();
+    let b = a.pow(2);
+
+    require(b == 0_u64, b);
+}
+
+#[test]
+fn math_u256_overflow_pow() {
+    let _ = disable_panic_on_overflow();
+
+    let a = u256::max();
+    let b = a.pow(2);
+
+    require(b == 0.as_u256(), b);
+}
diff --git a/test/src/in_language_tests/test_programs/output_inline_tests/Forc.toml b/test/src/in_language_tests/test_programs/output_inline_tests/Forc.toml
new file mode 100644
index 00000000000..fb1e5bc6a0f
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/output_inline_tests/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "output_inline_tests"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/in_language_tests/test_programs/output_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/output_inline_tests/src/main.sw
new file mode 100644
index 00000000000..1a02f200069
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/output_inline_tests/src/main.sw
@@ -0,0 +1,46 @@
+library;
+
+use std::outputs::Output;
+
+#[test]
+fn output_output_eq() {
+    let output_1 = Output::Coin;
+    let output_2 = Output::Coin;
+    let output_3 = Output::Contract;
+    let output_4 = Output::Contract;
+    let output_5 = Output::Change;
+    let output_6 = Output::Change;
+    let output_7 = Output::Variable;
+    let output_8 = Output::Variable;
+    let output_9 = Output::ContractCreated;
+    let output_10 = Output::ContractCreated;
+
+    assert(output_1 == output_2);
+    assert(output_3 == output_4);
+    assert(output_5 == output_6);
+    assert(output_7 == output_8);
+    assert(output_9 == output_10);
+}
+
+#[test]
+fn output_output_neq() {
+    let output_1 = Output::Coin;
+    let output_2 = Output::Contract;
+    let output_3 = Output::Change;
+    let output_4 = Output::Variable;
+    let output_5 = Output::ContractCreated;
+
+    assert(output_1 != output_2);
+    assert(output_1 != output_3);
+    assert(output_1 != output_4);
+    assert(output_1 != output_5);
+
+    assert(output_2 != output_3);
+    assert(output_2 != output_4);
+    assert(output_2 != output_5);
+
+    assert(output_3 != output_4);
+    assert(output_3 != output_5);
+
+    assert(output_4 != output_5);
+}
diff --git a/test/src/in_language_tests/test_programs/result_inline_tests/src/eq.sw b/test/src/in_language_tests/test_programs/result_inline_tests/src/eq.sw
new file mode 100644
index 00000000000..18ce687b26e
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/result_inline_tests/src/eq.sw
@@ -0,0 +1,114 @@
+library;
+
+#[test]
+fn test_eq_u64_u64() {
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Ok(0);
+    assert_eq(a, b);
+
+    let a: Result<u64, u64> = Ok(1);
+    let b: Result<u64, u64> = Ok(1);
+    assert_eq(a, b);
+
+    let a: Result<u64, u64> = Ok(42);
+    let b: Result<u64, u64> = Ok(42);
+    assert_eq(a, b);
+
+    let a: Result<u64, u64> = Ok(u64::max());
+    let b: Result<u64, u64> = Ok(u64::max());
+    assert_eq(a, b);
+}
+
+#[test]
+fn test_neq_u64_u64() {
+    // Ok
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Ok(1);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Ok(42);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Ok(u64::max());
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(1);
+    let b: Result<u64, u64> = Ok(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(42);
+    let b: Result<u64, u64> = Ok(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(u64::max());
+    let b: Result<u64, u64> = Ok(0);
+    assert_ne(a, b);
+
+    // Err
+    let a: Result<u64, u64> = Err(0);
+    let b: Result<u64, u64> = Err(1);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Err(0);
+    let b: Result<u64, u64> = Err(42);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Err(0);
+    let b: Result<u64, u64> = Err(u64::max());
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Err(1);
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Err(42);
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Err(u64::max());
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+
+    // Ok-Err
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(1);
+    let b: Result<u64, u64> = Err(1);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(42);
+    let b: Result<u64, u64> = Err(42);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(u64::max());
+    let b: Result<u64, u64> = Err(u64::max());
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Err(1);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Err(42);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(0);
+    let b: Result<u64, u64> = Err(u64::max());
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(1);
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(42);
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+
+    let a: Result<u64, u64> = Ok(u64::max());
+    let b: Result<u64, u64> = Err(0);
+    assert_ne(a, b);
+}
diff --git a/test/src/in_language_tests/test_programs/result_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/result_inline_tests/src/main.sw
index 2166d4b643b..381c4ec24f5 100644
--- a/test/src/in_language_tests/test_programs/result_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/result_inline_tests/src/main.sw
@@ -1,5 +1,7 @@
 library;
 
+mod eq;
+
 #[test]
 fn result_is_ok() {
     use std::bytes::Bytes;
diff --git a/test/src/in_language_tests/test_programs/storage_key_inline_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_key_inline_tests/Forc.toml
new file mode 100644
index 00000000000..3c59adb523a
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/storage_key_inline_tests/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "storage_key_inline_tests"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/in_language_tests/test_programs/storage_key_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_key_inline_tests/src/main.sw
new file mode 100644
index 00000000000..f2b9523e394
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/storage_key_inline_tests/src/main.sw
@@ -0,0 +1,123 @@
+library;
+
+#[test]
+fn storage_key_slot() {
+    let key_1 = StorageKey::<u64>::new(b256::min(), u64::zero(), b256::zero());
+    assert(key_1.slot() == b256::min());
+
+    let key_2 = StorageKey::<u64>::new(
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+        u64::zero(),
+        b256::zero(),
+    );
+    assert(
+        key_2
+            .slot() == 0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+
+    let key_3 = StorageKey::<u64>::new(b256::max(), u64::zero(), b256::zero());
+    assert(key_3.slot() == b256::max());
+}
+
+#[test]
+fn storage_key_offset() {
+    let key_1 = StorageKey::<u64>::new(b256::zero(), u64::min(), b256::zero());
+    assert(key_1.offset() == u64::min());
+
+    let key_2 = StorageKey::<u64>::new(b256::zero(), 1, b256::zero());
+    assert(key_2.offset() == 1);
+
+    let key_3 = StorageKey::<u64>::new(b256::zero(), u64::max(), b256::zero());
+    assert(key_3.offset() == u64::max());
+}
+
+#[test]
+fn storage_key_field_id() {
+    let key_1 = StorageKey::<u64>::new(b256::zero(), u64::zero(), b256::min());
+    assert(key_1.field_id() == b256::min());
+
+    let key_2 = StorageKey::<u64>::new(
+        b256::zero(),
+        u64::zero(),
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+    assert(
+        key_2
+            .field_id() == 0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+
+    let key_3 = StorageKey::<u64>::new(b256::zero(), u64::zero(), b256::max());
+    assert(key_3.field_id() == b256::max());
+}
+
+#[test]
+fn storage_key_new() {
+    let key = StorageKey::<u64>::new(b256::min(), u64::min(), b256::min());
+    assert(key.slot() == b256::min());
+    assert(key.offset() == u64::min());
+    assert(key.field_id() == b256::min());
+
+    let key = StorageKey::<u64>::new(
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+        1,
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+    assert(
+        key
+            .slot() == 0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+    assert(key.offset() == 1);
+    assert(
+        key
+            .field_id() == 0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+
+    let key = StorageKey::<u64>::new(b256::max(), u64::max(), b256::max());
+    assert(key.slot() == b256::max());
+    assert(key.offset() == u64::max());
+    assert(key.field_id() == b256::max());
+}
+
+#[test]
+fn storage_key_zero() {
+    let storage_key = StorageKey::<u64>::zero();
+    assert(
+        storage_key
+            .slot() == 0x0000000000000000000000000000000000000000000000000000000000000000,
+    );
+    assert(storage_key.offset() == 0);
+    assert(
+        storage_key
+            .field_id() == 0x0000000000000000000000000000000000000000000000000000000000000000,
+    );
+}
+
+#[test]
+fn storage_key_is_zero() {
+    let zero_storage_key = StorageKey::<u64>::zero();
+    assert(zero_storage_key.is_zero());
+
+    let storage_key_2 = StorageKey::<u64>::new(
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+        0,
+        0x0000000000000000000000000000000000000000000000000000000000000000,
+    );
+    assert(!storage_key_2.is_zero());
+
+    let storage_key_3 = StorageKey::<u64>::new(
+        0x0000000000000000000000000000000000000000000000000000000000000000,
+        1,
+        0x0000000000000000000000000000000000000000000000000000000000000000,
+    );
+    assert(!storage_key_3.is_zero());
+
+    let storage_key_4 = StorageKey::<u64>::new(
+        0x0000000000000000000000000000000000000000000000000000000000000000,
+        0,
+        0x0000000000000000000000000000000000000000000000000000000000000001,
+    );
+    assert(!storage_key_4.is_zero());
+
+    let storage_key_5 = StorageKey::<u64>::new(b256::max(), u64::max(), b256::max());
+    assert(!storage_key_5.is_zero());
+}
diff --git a/test/src/in_language_tests/test_programs/string_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/string_inline_tests/src/main.sw
index ec1313fa345..079a28ee78d 100644
--- a/test/src/in_language_tests/test_programs/string_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/string_inline_tests/src/main.sw
@@ -55,7 +55,6 @@ fn string_clear_empty() {
 #[test]
 fn string_from_ascii() {
     let mut bytes = Bytes::new();
-
     bytes.push(0u8);
     bytes.push(1u8);
     bytes.push(2u8);
@@ -63,11 +62,15 @@ fn string_from_ascii() {
     bytes.push(4u8);
 
     let mut string_from_ascii = String::from_ascii(bytes);
-    assert(bytes.capacity() == string_from_ascii.capacity());
+    assert(bytes.len() == string_from_ascii.capacity());
+
     let bytes = string_from_ascii.as_bytes();
     assert(bytes.get(0).unwrap() == 0u8);
     assert(bytes.get(1).unwrap() == 1u8);
     assert(bytes.get(2).unwrap() == 2u8);
+    assert(bytes.get(3).unwrap() == 3u8);
+    assert(bytes.get(4).unwrap() == 4u8);
+    assert(bytes.get(5) == None);
 }
 
 #[test]
@@ -147,7 +150,7 @@ fn string_ptr() {
 
     let mut string_from_ascii = String::from_ascii(bytes);
     assert(!string_from_ascii.ptr().is_null());
-    assert(string_from_ascii.ptr() == bytes.ptr());
+    assert(string_from_ascii.ptr() != bytes.ptr());
 }
 
 #[test]
diff --git a/test/src/in_language_tests/test_programs/tx_inline_tests/Forc.toml b/test/src/in_language_tests/test_programs/tx_inline_tests/Forc.toml
new file mode 100644
index 00000000000..fa38e2fc473
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/tx_inline_tests/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_inline_tests"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/in_language_tests/test_programs/tx_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/tx_inline_tests/src/main.sw
new file mode 100644
index 00000000000..018763a31b8
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/tx_inline_tests/src/main.sw
@@ -0,0 +1,129 @@
+library;
+
+use std::tx::Transaction;
+
+#[test]
+fn tx_transaction_eq() {
+    let transaction_1 = Transaction::Script;
+    let transaction_2 = Transaction::Script;
+    let transaction_3 = Transaction::Create;
+    let transaction_4 = Transaction::Create;
+    let transaction_5 = Transaction::Mint;
+    let transaction_6 = Transaction::Mint;
+    let transaction_7 = Transaction::Upgrade;
+    let transaction_8 = Transaction::Upgrade;
+    let transaction_9 = Transaction::Upload;
+    let transaction_10 = Transaction::Upload;
+    let transaction_11 = Transaction::Blob;
+    let transaction_12 = Transaction::Blob;
+
+    assert(transaction_1 == transaction_1);
+    assert(transaction_1 == transaction_2);
+    assert(transaction_2 == transaction_2);
+
+    assert(transaction_3 == transaction_3);
+    assert(transaction_3 == transaction_4);
+    assert(transaction_4 == transaction_4);
+
+    assert(transaction_5 == transaction_5);
+    assert(transaction_5 == transaction_6);
+    assert(transaction_6 == transaction_6);
+
+    assert(transaction_7 == transaction_7);
+    assert(transaction_7 == transaction_8);
+    assert(transaction_8 == transaction_8);
+
+    assert(transaction_9 == transaction_9);
+    assert(transaction_9 == transaction_10);
+    assert(transaction_10 == transaction_10);
+
+    assert(transaction_11 == transaction_11);
+    assert(transaction_11 == transaction_12);
+    assert(transaction_12 == transaction_12);
+}
+
+#[test]
+fn tx_transaction_ne() {
+    let transaction_1 = Transaction::Script;
+    let transaction_2 = Transaction::Script;
+    let transaction_3 = Transaction::Create;
+    let transaction_4 = Transaction::Create;
+    let transaction_5 = Transaction::Mint;
+    let transaction_6 = Transaction::Mint;
+    let transaction_7 = Transaction::Upgrade;
+    let transaction_8 = Transaction::Upgrade;
+    let transaction_9 = Transaction::Upload;
+    let transaction_10 = Transaction::Upload;
+    let transaction_11 = Transaction::Blob;
+    let transaction_12 = Transaction::Blob;
+
+    assert(transaction_1 != transaction_3);
+    assert(transaction_1 != transaction_4);
+    assert(transaction_1 != transaction_5);
+    assert(transaction_1 != transaction_6);
+    assert(transaction_1 != transaction_7);
+    assert(transaction_1 != transaction_8);
+    assert(transaction_1 != transaction_9);
+    assert(transaction_1 != transaction_10);
+    assert(transaction_1 != transaction_11);
+    assert(transaction_1 != transaction_12);
+
+    assert(transaction_2 != transaction_3);
+    assert(transaction_2 != transaction_4);
+    assert(transaction_2 != transaction_5);
+    assert(transaction_2 != transaction_6);
+    assert(transaction_2 != transaction_7);
+    assert(transaction_2 != transaction_8);
+    assert(transaction_2 != transaction_9);
+    assert(transaction_2 != transaction_10);
+    assert(transaction_2 != transaction_11);
+    assert(transaction_2 != transaction_12);
+
+    assert(transaction_3 != transaction_5);
+    assert(transaction_3 != transaction_6);
+    assert(transaction_3 != transaction_7);
+    assert(transaction_3 != transaction_8);
+    assert(transaction_3 != transaction_9);
+    assert(transaction_3 != transaction_10);
+    assert(transaction_3 != transaction_11);
+    assert(transaction_3 != transaction_12);
+
+    assert(transaction_4 != transaction_5);
+    assert(transaction_4 != transaction_6);
+    assert(transaction_4 != transaction_7);
+    assert(transaction_4 != transaction_8);
+    assert(transaction_4 != transaction_9);
+    assert(transaction_4 != transaction_10);
+    assert(transaction_4 != transaction_11);
+    assert(transaction_4 != transaction_12);
+
+    assert(transaction_5 != transaction_7);
+    assert(transaction_5 != transaction_8);
+    assert(transaction_5 != transaction_9);
+    assert(transaction_5 != transaction_10);
+    assert(transaction_5 != transaction_11);
+    assert(transaction_5 != transaction_12);
+
+    assert(transaction_6 != transaction_7);
+    assert(transaction_6 != transaction_8);
+    assert(transaction_6 != transaction_9);
+    assert(transaction_6 != transaction_10);
+    assert(transaction_6 != transaction_11);
+    assert(transaction_6 != transaction_12);
+
+    assert(transaction_7 != transaction_9);
+    assert(transaction_7 != transaction_10);
+    assert(transaction_7 != transaction_11);
+    assert(transaction_7 != transaction_12);
+
+    assert(transaction_8 != transaction_9);
+    assert(transaction_8 != transaction_10);
+    assert(transaction_8 != transaction_11);
+    assert(transaction_8 != transaction_12);
+
+    assert(transaction_9 != transaction_11);
+    assert(transaction_9 != transaction_12);
+
+    assert(transaction_10 != transaction_11);
+    assert(transaction_10 != transaction_12);
+}
diff --git a/test/src/in_language_tests/test_programs/u128_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/u128_inline_tests/src/main.sw
index c7fc8405215..4d7acda31fb 100644
--- a/test/src/in_language_tests/test_programs/u128_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/u128_inline_tests/src/main.sw
@@ -1,6 +1,6 @@
 library;
 
-use std::u128::U128;
+use std::{u128::U128, registers::flags, flags::{set_flags, disable_panic_on_unsafe_math, disable_panic_on_overflow}};
 
 #[test]
 fn u128_from_u8() {
@@ -688,6 +688,8 @@ fn u128_root() {
 
 #[test]
 fn u128_log() {
+    let prior_flags = flags();
+
     let u_128_0: U128 = U128::from((0, 0));
     let u_128_1: U128 = U128::from((0, 1));
     let u_128_2: U128 = U128::from((0, 2));
@@ -696,12 +698,12 @@ fn u128_log() {
     let u_128_8: U128 = U128::from((0, 8));
     let u_128_9: U128 = U128::from((0, 9));
     let u_128_10: U128 = U128::from((0, 10));
-    let u_128_21: U128 = U128::from((0, 21));
+    let u_128_20: U128 = U128::from((0, 20));
     let u_128_42: U128 = U128::from((0, 42));
     let u_128_64: U128 = U128::from((0, 64));
     let u_128_100: U128 = U128::from((0, 100));
     let u_128_127: U128 = U128::from((0, 127));
-    let u_128_max_div_2: U128 = U128::from((1, 0));
+    let u64_max_times_two: U128 = U128::from((1, 0));
     let u_128_max: U128 = U128::max();
 
     assert(u_128_2.log(u_128_2) == u_128_1);
@@ -712,8 +714,37 @@ fn u128_log() {
     assert(u_128_100.log(u_128_9) == u_128_2);
     assert(u_128_max.log(u_128_2) == u_128_127);
     assert(u_128_max.log(u_128_9) == u_128_42);
-    assert(u_128_max_div_2.log(u_128_2) == u_128_64);
-    assert(u_128_max_div_2.log(u_128_9) == u_128_21);
+    assert(u64_max_times_two.log(u_128_2) == u_128_64);
+    assert(u64_max_times_two.log(u_128_9) == u_128_20);
+
+    assert(prior_flags == flags());
+
+    let prior_flags = disable_panic_on_unsafe_math();
+
+    let before_flags = flags();
+
+    let zero = U128::from(0_u64);
+    let one = U128::from(1_u64);
+    let three = U128::from(3_u64);
+
+    assert(one.log(one) == zero);
+    assert(zero.log(three) == zero);
+
+    assert(before_flags == flags());
+
+    set_flags(prior_flags);
+}
+
+#[test(should_revert)]
+fn revert_unsafe_math_u128_1log1() {
+    let res = U128::from(1_u64).log(U128::from(1_u64));
+    log(res);
+}
+
+#[test(should_revert)]
+fn revert_unsafe_math_u128_0log_3() {
+    let res = U128::from(0_u64).log(U128::from(3_u64));
+    log(res);
 }
 
 #[test]
@@ -742,3 +773,312 @@ fn revert_u128_binary_log() {
 
     let _result = u_128_0.log2();
 }
+
+#[test]
+fn parity_u128_log_with_ruint() {
+    let prior_flags = flags();
+
+    // Failure cases found by comparing parity with ruint implementation of U128
+    // https://docs.rs/ruint/latest/src/ruint/log.rs.html#45-89
+    let a = [
+        2, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10,
+        10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 14, 14, 15, 16, 16, 16, 16, 16,
+        16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+        17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20,
+        20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+        21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+        23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25,
+        25, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 29,
+        29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+        32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33,
+        33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+        33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
+        34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35,
+        35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
+        35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+        36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+        37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+        38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39,
+        39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40,
+        40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+        41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+        41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+        42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+        44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 45,
+        45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46,
+        46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47,
+        47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
+        48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 50, 50, 50, 50, 50,
+        50, 50, 50, 50, 50, 50, 50, 50, 50, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 52,
+        52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 54,
+        54, 54, 54, 54, 54, 54, 54, 54, 54, 55, 55, 55, 55, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56,
+        56, 56, 56, 57, 57, 57, 57, 57, 57, 57, 58, 58, 58, 58, 58, 58, 59, 59, 59, 59, 59, 60, 60,
+        60, 60, 61, 61, 61, 62, 62, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+        64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+        65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+        65, 65, 65, 65, 65, 65, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+        66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+        66, 66, 66, 66, 66, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
+        67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
+        67, 67, 67, 67, 67, 67, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+        68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+        68, 68, 68, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+        69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 70,
+        70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
+        70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 71, 71, 71, 71, 71, 71,
+        71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
+        71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
+        72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
+        72, 72, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+        73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 74, 74, 74, 74,
+        74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74,
+        74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+        75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+        76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+        76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+        77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+        78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+        78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
+        79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 80, 80, 80, 80,
+        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
+        80, 80, 80, 80, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
+        81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82,
+        82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 83, 83, 83, 83, 83, 83, 83, 83,
+        83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 84, 84, 84, 84,
+        84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 85,
+        85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+        85, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
+        86, 86, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+        87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
+        88, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 90,
+        90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 91, 91, 91, 91,
+        91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 92, 92, 92, 92, 92, 92, 92, 92,
+        92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+        93, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 95, 95,
+        95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
+        96, 96, 96, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 98, 98, 98, 98, 98, 98, 98,
+        98, 98, 98, 98, 98, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 100, 100, 100, 100, 100,
+        100, 100, 100, 100,
+    ];
+    let b = [
+        3, 3, 5, 6, 7, 3, 6, 7, 3, 7, 3, 3, 9, 10, 11, 12, 13, 14, 15, 3, 10, 11, 12, 13, 14, 15,
+        3, 11, 12, 13, 14, 15, 3, 12, 13, 14, 15, 3, 13, 14, 15, 3, 14, 15, 3, 15, 3, 3, 5, 6, 7,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 18, 19, 20, 21, 22,
+        23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+        30, 31, 3, 5, 6, 7, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 21, 22, 23,
+        24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5,
+        6, 7, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5, 6, 7, 24, 25, 26, 27, 28, 29, 30, 31, 3, 5,
+        6, 7, 25, 26, 27, 28, 29, 30, 31, 3, 6, 7, 26, 27, 28, 29, 30, 31, 3, 6, 7, 27, 28, 29, 30,
+        31, 3, 6, 7, 28, 29, 30, 31, 3, 6, 7, 29, 30, 31, 3, 6, 7, 30, 31, 3, 6, 7, 31, 3, 6, 7, 3,
+        6, 7, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+        54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 6, 7, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+        44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 6, 7,
+        35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+        58, 59, 60, 61, 62, 63, 3, 6, 7, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 37, 38, 39, 40, 41, 42, 43,
+        44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 38,
+        39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+        62, 63, 3, 7, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+        58, 59, 60, 61, 62, 63, 3, 7, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+        55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+        53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+        53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+        55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+        58, 59, 60, 61, 62, 63, 3, 7, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+        62, 63, 3, 7, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 7, 49, 50,
+        51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 50, 51, 52, 53, 54, 55, 56, 57, 58,
+        59, 60, 61, 62, 63, 3, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 52, 53, 54,
+        55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 54,
+        55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3, 56, 57, 58,
+        59, 60, 61, 62, 63, 3, 57, 58, 59, 60, 61, 62, 63, 3, 58, 59, 60, 61, 62, 63, 3, 59, 60,
+        61, 62, 63, 3, 60, 61, 62, 63, 3, 61, 62, 63, 3, 62, 63, 3, 63, 3, 3, 5, 6, 7, 9, 10, 11,
+        12, 13, 14, 15, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+        84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11,
+        12, 13, 14, 15, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+        85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12,
+        13, 14, 15, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+        87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14,
+        15, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 69, 70,
+        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
+        94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 70, 71, 72, 73, 74, 75,
+        76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+        99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+        82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9,
+        10, 11, 12, 13, 14, 15, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+        89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 73,
+        74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
+        97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+        83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10,
+        11, 12, 13, 14, 15, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+        93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 76, 77, 78, 79, 80,
+        81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6,
+        7, 9, 10, 11, 12, 13, 14, 15, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+        92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 78, 79, 80, 81,
+        82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9,
+        10, 11, 12, 13, 14, 15, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+        96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 80, 81, 82, 83, 84, 85, 86, 87,
+        88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15,
+        81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6,
+        7, 10, 11, 12, 13, 14, 15, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
+        98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+        93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 84, 85, 86, 87, 88,
+        89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 85,
+        86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13,
+        14, 15, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11,
+        12, 13, 14, 15, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10,
+        11, 12, 13, 14, 15, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10,
+        11, 12, 13, 14, 15, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11,
+        12, 13, 14, 15, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13,
+        14, 15, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 92,
+        93, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 93, 94, 95, 96, 97,
+        98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 94, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7,
+        10, 11, 12, 13, 14, 15, 95, 96, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 96,
+        97, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 97, 98, 99, 100, 3, 5, 6, 7, 10, 11,
+        12, 13, 14, 15, 98, 99, 100, 3, 5, 6, 7, 10, 11, 12, 13, 14, 15, 99, 100, 3, 5, 6, 7, 10,
+        11, 12, 13, 14, 15, 100, 3, 5, 6, 7, 11, 12, 13, 14, 15,
+    ];
+    let expected = [
+        0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
+        0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 2, 0, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 0, 0,
+        0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0, 3, 1, 1, 0,
+        0, 0, 3, 1, 1, 0, 0, 3, 1, 1, 0, 3, 1, 1, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0,
+        0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 3, 0, 3, 3, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2,
+        2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2,
+        2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1,
+        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 4, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4, 2, 2, 2, 1, 1, 1,
+        1, 1, 1, 0, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 4, 2, 2, 2, 1, 1, 1, 1, 1,
+    ];
+
+    let mut i = 0;
+
+    while i < 1825 {
+        let ai: u64 = a[i];
+        let bi: u64 = b[i];
+        let expected_val: u64 = expected[i];
+
+        let result = U128::from(ai).log(U128::from(bi));
+        assert_eq(result, U128::from(expected_val));
+        i += 1;
+    }
+
+    assert(prior_flags == flags());
+}
+
+#[test]
+fn u128_overflowing_add() {
+    let prior_flags = disable_panic_on_overflow();
+    let a = U128::max();
+    let b = U128::from((0, 1));
+    let c = a + b;
+
+    assert(c == U128::from((0, 0)));
+
+    set_flags(prior_flags);
+}
+
+#[test]
+fn u128_underflowing_sub() {
+    let prior_flags = disable_panic_on_overflow();
+    let a = U128::from((0, 1));
+    let b = U128::from((0, 2));
+    let c = a - b;
+
+    assert(c == U128::max());
+
+    set_flags(prior_flags);
+}
+
+#[test]
+fn u128_overflowing_mul() {
+    let prior_flags = disable_panic_on_overflow();
+    let a = U128::max();
+    let b = U128::from((0, 2));
+    let c = a * b;
+
+    // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE
+    assert(c == U128::from((0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE)));
+
+    set_flags(prior_flags);
+}
+
+#[test]
+fn u128_overflowing_pow() {
+    // Overflow on pow should return 0 if panic is disabled
+    let prior_flags = disable_panic_on_overflow();
+    let a = U128::max();
+
+    let res = a.pow(2);
+    
+    assert(res == U128::from((0, 0)));
+
+    set_flags(prior_flags);
+}
+
+#[test]
+fn u128_unsafemath_log2() {
+    let prior_flags = disable_panic_on_unsafe_math();
+    // 0 is not a valid operand for log2
+    let a = U128::zero();
+    let res = a.log2();
+
+    assert(res == U128::zero());
+
+    set_flags(prior_flags);
+}
\ No newline at end of file
diff --git a/test/src/in_language_tests/test_programs/vec_inline_tests/src/main.sw b/test/src/in_language_tests/test_programs/vec_inline_tests/src/main.sw
index 5ac6a8fef32..78e2df5d1e5 100644
--- a/test/src/in_language_tests/test_programs/vec_inline_tests/src/main.sw
+++ b/test/src/in_language_tests/test_programs/vec_inline_tests/src/main.sw
@@ -641,7 +641,7 @@ fn vec_from_raw_slice() {
     };
 
     let mut vec: Vec<u64> = Vec::from(slice);
-    assert(vec.ptr() == slice.ptr());
+    assert(vec.ptr() != slice.ptr()); // Vec should own its buffer
     assert(vec.len() == slice.len::<u64>());
 }
 
@@ -683,7 +683,7 @@ fn vec_raw_slice_into() {
 
     let vec: Vec<u64> = slice.into();
 
-    assert(vec.ptr() == slice.ptr());
+    assert(vec.ptr() != slice.ptr()); // Vec should own its buffer
     assert(vec.len() == slice.len::<u64>());
 }
 
diff --git a/test/src/ir_generation/README.md b/test/src/ir_generation/README.md
index ac7bfd8b7ca..051a454bbfd 100644
--- a/test/src/ir_generation/README.md
+++ b/test/src/ir_generation/README.md
@@ -28,7 +28,7 @@ Both checks against IR and ASM may be provided in the same Sway test source file
 To delimit between checks against IR and those against ASM the source file may be split into sections using delimiting marker text.
 
 * `::check-ir::` marks the beginning of the IR checks.
-* `::check-ir-optimized::` marks the begingging of the optimized IR checks.
+* `::check-ir-optimized::` marks the beginning of the optimized IR checks.
 * `::check-asm::` marks the beginning of the ASM checks.
 
   Optimized IR checker can be configured with `pass: <PASSNAME or o1>`. When
diff --git a/test/src/ir_generation/mod.rs b/test/src/ir_generation/mod.rs
index 2c21d60c91e..9de1ab9f2e1 100644
--- a/test/src/ir_generation/mod.rs
+++ b/test/src/ir_generation/mod.rs
@@ -8,8 +8,8 @@ use std::{
 use anyhow::Result;
 use colored::Colorize;
 use sway_core::{
-    compile_ir_context_to_finalized_asm, compile_to_ast, ir_generation::compile_program, namespace,
-    BuildTarget, Engines,
+    compile_ir_context_to_finalized_asm, compile_to_ast, ir_generation::compile_program,
+    language::Visibility, namespace, BuildTarget, Engines,
 };
 use sway_error::handler::Handler;
 
@@ -31,7 +31,7 @@ impl Checker {
     /// of the file.
     /// Example:
     ///
-    /// ```
+    /// ```sway
     /// // ::check-ir::
     /// // ::check-ir-optimized::
     /// // ::check-ir-asm::
@@ -42,7 +42,7 @@ impl Checker {
     /// Optimized IR checker can be configured with `pass: <PASSNAME or o1>`. When
     /// `o1` is chosen, all the configured passes are chosen automatically.
     ///
-    /// ```
+    /// ```sway
     /// // ::check-ir-optimized::
     /// // pass: o1
     /// ```
@@ -171,16 +171,16 @@ pub(super) async fn run(
     // TODO the way modules are built for these tests, new_encoding is not working.
     experimental.new_encoding = false;
 
-    // Compile core library and reuse it when compiling tests.
-    let engines = Engines::default();
-    let build_target = BuildTarget::default();
-    let mut core_lib = compile_core(build_target, &engines, experimental);
-
     // Create new initial namespace for every test by reusing the precompiled
     // standard libraries. The namespace, thus its root module, must have the
     // name set.
     const PACKAGE_NAME: &str = "test_lib";
-    core_lib.name = Some(sway_types::Ident::new_no_span(PACKAGE_NAME.to_string()));
+    let core_lib_name = sway_types::Ident::new_no_span(PACKAGE_NAME.to_string());
+
+    // Compile core library and reuse it when compiling tests.
+    let engines = Engines::default();
+    let build_target = BuildTarget::default();
+    let core_lib = compile_core(core_lib_name, build_target, &engines, experimental);
 
     // Find all the tests.
     let all_tests = discover_test_files();
@@ -238,12 +238,12 @@ pub(super) async fn run(
 
                 let sway_str = String::from_utf8_lossy(&sway_str);
                 let handler = Handler::default();
-                let initial_namespace = namespace::Root::from(core_lib.clone());
+                let mut initial_namespace = namespace::Root::from(core_lib.clone());
                 let compile_res = compile_to_ast(
                     &handler,
                     &engines,
                     Arc::from(sway_str),
-                    initial_namespace,
+                    &mut initial_namespace,
                     Some(&bld_cfg),
                     PACKAGE_NAME,
                     None,
@@ -527,6 +527,7 @@ fn discover_test_files() -> Vec<PathBuf> {
 }
 
 fn compile_core(
+    lib_name: sway_types::Ident,
     build_target: BuildTarget,
     engines: &Engines,
     experimental: ExperimentalFlags,
@@ -563,7 +564,11 @@ fn compile_core(
                 .submodules()
                 .into_iter()
                 .fold(
-                    namespace::Module::default(),
+                    namespace::Module::new(
+                        sway_types::Ident::new_no_span("core".to_string()),
+                        Visibility::Private,
+                        None,
+                    ),
                     |mut core_mod, (name, sub_mod)| {
                         core_mod.insert_submodule(name.clone(), sub_mod.clone());
                         core_mod
@@ -571,7 +576,7 @@ fn compile_core(
                 );
 
             // Create a module for std and insert the core module.
-            let mut std_module = namespace::Module::default();
+            let mut std_module = namespace::Module::new(lib_name, Visibility::Private, None);
             std_module.insert_submodule("core".to_owned(), core_module);
             std_module
         }
diff --git a/test/src/ir_generation/tests/addr_of.sw b/test/src/ir_generation/tests/addr_of.sw
index e8ec2c8ed88..9590d222a52 100644
--- a/test/src/ir_generation/tests/addr_of.sw
+++ b/test/src/ir_generation/tests/addr_of.sw
@@ -1,4 +1,3 @@
-
 script;
 
 fn main() {
@@ -6,10 +5,10 @@ fn main() {
     let _ = __addr_of(a);
 }
 
-// check: v0 = get_local ptr b256, a, !2
-// check: v1 = const b256 0x0000000000000000000000000000000000000000000000000000000000000001, !3
-// check: store v1 to v0, !2
-// check: v2 = get_local ptr b256, a, !4
-// check: v3 = ptr_to_int v2 to u64, !5
-// check: v4 = get_local ptr u64, _, !6
-// check: store v3 to v4, !6
+// check: v0 = get_local ptr b256, a,
+// check: v1 = const b256 0x0000000000000000000000000000000000000000000000000000000000000001,
+// check: store v1 to v0,
+// check: v2 = get_local ptr b256, a,
+// check: v3 = ptr_to_int v2 to u64,
+// check: v4 = get_local ptr u64, _,
+// check: store v3 to v4,
diff --git a/test/src/ir_generation/tests/empty.sw b/test/src/ir_generation/tests/empty.sw
index d58938be4e3..37453757bf0 100644
--- a/test/src/ir_generation/tests/empty.sw
+++ b/test/src/ir_generation/tests/empty.sw
@@ -11,7 +11,8 @@ fn main() {
 // ::check-asm::
 // The data section setup:
 // check: move $$$$locbase $$sp
-// check: cfei i0
+// not: cfei i0
+// not: cfsi i0
 // check: ret  $$zero
 // nextln: .data
 // not: data_
diff --git a/test/src/ir_generation/tests/eq_intrinsic.sw b/test/src/ir_generation/tests/eq_intrinsic.sw
index 832c0ea958e..8e69094fd5a 100644
--- a/test/src/ir_generation/tests/eq_intrinsic.sw
+++ b/test/src/ir_generation/tests/eq_intrinsic.sw
@@ -5,6 +5,6 @@ fn main() -> bool {
   true
 }
 
-// check: $(l=$VAL) = const u64 1, !2
-// check: $(r=$VAL) = const u64 2, !3
+// check: $(l=$VAL) = const u64 1,
+// check: $(r=$VAL) = const u64 2,
 // check: cmp eq $l $r
diff --git a/test/src/ir_generation/tests/fn_call_ret_by_ref_explicit.sw b/test/src/ir_generation/tests/fn_call_ret_by_ref_explicit.sw
index 12f5f2b2717..0fadcbfa548 100644
--- a/test/src/ir_generation/tests/fn_call_ret_by_ref_explicit.sw
+++ b/test/src/ir_generation/tests/fn_call_ret_by_ref_explicit.sw
@@ -16,7 +16,7 @@ fn main() -> u64 {
 
 // ::check-ir::
 
-// There are return value '__ret_val' temporaries and there are other '__anon_' temporaries and in
+// There are return value '__ret_val' temporaries and there are other '__aggr_memcpy_' temporaries and in
 // this test we want to match the return values specifically.  If we ever rename them from
 // '__ret_val_' to something else then this test will fail.
 
@@ -31,8 +31,9 @@ fn main() -> u64 {
 // check: $(tmp_ptr=$VAL) = get_local ptr { u64, u64, u64 }, $ID
 // check: mem_copy_val $tmp_ptr, $ret_val_0
 
+// check: $(tmp_ptr_rep=$VAL) = get_local ptr { u64, u64, u64 }, $(=__aggr_memcpy_\d+)
 // check: $(idx_val=$VAL) = const u64 1
-// check: $(field_val=$VAL) = get_elem_ptr $tmp_ptr, ptr u64, $idx_val
+// check: $(field_val=$VAL) = get_elem_ptr $tmp_ptr_rep, ptr u64, $idx_val
 // check: load $field_val
 
 // check: $(ret_arg_1=$VAL) = get_local ptr { u64, u64, u64 }, $ret_for_call_1
@@ -40,8 +41,9 @@ fn main() -> u64 {
 // check: $(tmp_ptr=$VAL) = get_local ptr { u64, u64, u64 }, $ID
 // check: mem_copy_val $tmp_ptr, $ret_val_1
 
+// check: $(tmp_ptr_rep=$VAL) = get_local ptr { u64, u64, u64 }, $(=__aggr_memcpy_\d+)
 // check: $(idx_val=$VAL) = const u64 2
-// check: $(field_val=$VAL) = get_elem_ptr $tmp_ptr, ptr u64, $idx_val
+// check: $(field_val=$VAL) = get_elem_ptr $tmp_ptr_rep, ptr u64, $idx_val
 // check: load $field_val
 
 // fn a()...
diff --git a/test/src/ir_generation/tests/fn_call_ret_by_ref_implicit.sw b/test/src/ir_generation/tests/fn_call_ret_by_ref_implicit.sw
index ce3493bbc7b..c0cb8e481b8 100644
--- a/test/src/ir_generation/tests/fn_call_ret_by_ref_implicit.sw
+++ b/test/src/ir_generation/tests/fn_call_ret_by_ref_implicit.sw
@@ -19,19 +19,21 @@ fn main() -> u64 {
 // check: $(ret_val_ptr=$VAL) = get_local ptr { u64, u64, u64 }, $(=__ret_val.*)
 // check: $(arg_11=$VAL) = const u64 11
 // check: $(call_a_ret_ptr=$VAL) = call $(a_fn=$ID)($arg_11, $ret_val_ptr)
-// check: $(temp_0=$VAL) = get_local ptr { u64, u64, u64 }, $(=__anon_\d+)
+// check: $(temp_0=$VAL) = get_local ptr { u64, u64, u64 }, $(=__aggr_memcpy_\d+)
 // check: mem_copy_val $temp_0, $call_a_ret_ptr
 
+// check: $(temp_0_rep=$VAL) = get_local ptr { u64, u64, u64 }, $(=__aggr_memcpy_\d+)
 // check: $(idx_1=$VAL) = const u64 1
-// check: $(field_1_ptr=$VAL) = get_elem_ptr $temp_0, ptr u64, $idx_1
+// check: $(field_1_ptr=$VAL) = get_elem_ptr $temp_0_rep, ptr u64, $idx_1
 // check: $(field_1_val=$VAL) = load $field_1_ptr
 // check: $(ret_val_ptr=$VAL) = get_local ptr { u64, u64, u64 }, $(=__ret_val.*)
 // check: $(call_a_ret_ptr=$VAL) = call $a_fn($field_1_val, $ret_val_ptr)
-// check: $(temp_1=$VAL) = get_local ptr { u64, u64, u64 }, $(=__anon_\d+)
+// check: $(temp_1=$VAL) = get_local ptr { u64, u64, u64 }, $(=__aggr_memcpy_\d+)
 // check: mem_copy_val $temp_1, $call_a_ret_ptr
 
+// check: $(temp_1_rep=$VAL) = get_local ptr { u64, u64, u64 }, $(=__aggr_memcpy_\d+)
 // check: $(idx_2=$VAL) = const u64 2
-// check: $(field_2_ptr=$VAL) = get_elem_ptr $temp_1, ptr u64, $idx_2
+// check: $(field_2_ptr=$VAL) = get_elem_ptr $temp_1_rep, ptr u64, $idx_2
 // check: $(field_2_val=$VAL) = load $field_2_ptr
 // check: ret u64 $field_2_val
 
diff --git a/test/src/ir_generation/tests/jmp_mem.sw b/test/src/ir_generation/tests/jmp_mem.sw
index f4e998bea94..7861956060b 100644
--- a/test/src/ir_generation/tests/jmp_mem.sw
+++ b/test/src/ir_generation/tests/jmp_mem.sw
@@ -19,7 +19,7 @@ impl MyContract for Contract {
             csiz length code_id;
             // Save the old ssp
             move ssp_saved ssp;
-            ldc code_id zero length;
+            ldc code_id zero length i0;
             // Store the old ssp to MEM[$hp] so that we can jump to it.
             // allocate a word the stack
             addi word zero i64;
@@ -40,7 +40,7 @@ impl MyContract for Contract {
 // check: pub entry fn test_function
 // not: local
 // check: csiz   length code_id
-// check: ldc    code_id zero length,
+// check: ldc    code_id zero length i0,
 // check: jmp_mem
 
 // ::check-asm::
@@ -48,8 +48,8 @@ impl MyContract for Contract {
 // regex: REG=.r\d+\b
 
 // check: csiz $(len=$REG) $REG
-// check: ldc  $REG $$zero $len
-// check: lw   $(target=$REG) $$hp i0               ; jmp_mem: Load MEM[$$hp]
-// check: sub  $(jmp_target_4=$REG) $target $$is              ; jmp_mem: Subtract $$is since Jmp adds it back
-// check: divi $(jmp_target=$REG) $jmp_target_4 i4               ; jmp_mem: Divide by 4 since Jmp multiplies by 4
-// check: jmp $jmp_target                       ; jmp_mem: Jump to computed value
+// check: ldc  $REG $$zero $len i0
+// check: lw   $(target=$REG) $$hp i0
+// check: sub  $(jmp_target_4=$REG) $target $$is
+// check: divi $(jmp_target=$REG) $jmp_target_4 i4
+// check: jmp $jmp_target
diff --git a/test/src/ir_generation/tests/size_of_val.sw b/test/src/ir_generation/tests/size_of_val.sw
index e146794d1e7..22ce1aa011d 100644
--- a/test/src/ir_generation/tests/size_of_val.sw
+++ b/test/src/ir_generation/tests/size_of_val.sw
@@ -4,6 +4,6 @@ fn main() {
     let _ = __size_of_val(1);
 }
 
-// check: v0 = get_local ptr u64, _, !2
+// check: v0 = get_local ptr u64, _,
 // check: v1 = const u64 8
-// check: store v1 to v0, !2
+// check: store v1 to v0,
diff --git a/test/src/ir_generation/tests/state_load_word.sw b/test/src/ir_generation/tests/state_load_word.sw
index 72557769ae1..0f9e9578434 100644
--- a/test/src/ir_generation/tests/state_load_word.sw
+++ b/test/src/ir_generation/tests/state_load_word.sw
@@ -6,9 +6,9 @@ fn main() {
     );
 }
 
-// check: v0 = get_local ptr b256, key_for_storage, !2
-// check: v1 = const b256 0x0000000000000000000000000000000000000000000000000000000000000001, !3
-// check: store v1 to v0, !2
-// check: v2 = state_load_word key v0, !2
-// check: v3 = get_local ptr u64, _, !4
-// check: store v2 to v3, !4
+// check: v0 = get_local ptr b256, key_for_storage,
+// check: v1 = const b256 0x0000000000000000000000000000000000000000000000000000000000000001,
+// check: store v1 to v0,
+// check: v2 = state_load_word key v0,
+// check: v3 = get_local ptr u64, _,
+// check: store v2 to v3,
diff --git a/test/src/ir_generation/tests/storage_metadata.sw b/test/src/ir_generation/tests/storage_metadata.sw
index c29fc473715..0b3345f1265 100644
--- a/test/src/ir_generation/tests/storage_metadata.sw
+++ b/test/src/ir_generation/tests/storage_metadata.sw
@@ -49,12 +49,17 @@ impl Incrementor for Contract {
 // check: fn increment<e543c666>(increment_by $MD: u64) -> u64, $(increment_md=$MD) {
 // check: fn initialize<557ac400>(initial_value $MD: u64) -> u64, $(init_md=$MD) {
 
-// unordered: $(write_md=$MD) = storage "writes"
-// unordered: $(readwrite_md=$MD) = storage "readswrites"
-// unordered: $(read_md=$MD) = storage "reads"
+// unordered: $(write_md=$MD) = purity "writes"
+// unordered: $(write_fn_name_md=$MD) = fn_name_span $MD 359 369
 
-// The span idx is first, then the storage attribute.
+// unordered: $(readwrite_md=$MD) = purity "readswrites"
+// unordered: $(readwrite_fn_name_md=$MD) = fn_name_span $MD 553 562
 
-// unordered: $init_md = ($MD $write_md)
-// unordered: $increment_md = ($MD $readwrite_md)
-// unordered: $get_md = ($MD $read_md)
+// unordered: $(read_md=$MD) = purity "reads"
+// unordered: $(read_fn_name_md=$MD) = fn_name_span $MD 833 836
+
+// The span idx is first, then the storage attribute, then the function name attribute.
+
+// unordered: $init_md = ($MD $write_md $write_fn_name_md)
+// unordered: $increment_md = ($MD $readwrite_md $readwrite_fn_name_md)
+// unordered: $get_md = ($MD $read_md $read_fn_name_md)
\ No newline at end of file
diff --git a/test/src/ir_generation/tests/str_slice.sw b/test/src/ir_generation/tests/str_slice.sw
index ad2305d3652..e4a2e6c3ceb 100644
--- a/test/src/ir_generation/tests/str_slice.sw
+++ b/test/src/ir_generation/tests/str_slice.sw
@@ -11,11 +11,11 @@ fn main() -> u64 {
 // check: local slice a
 
 // check: v0 = const string<3> "abc"
-// check: v1 = ptr_to_int v0 to u64, !2
-// check: v2 = get_local ptr { u64, u64 }, __anon_0, !2
+// check: v1 = ptr_to_int v0 to u64,
+// check: v2 = get_local ptr { u64, u64 }, __anon_0,
 // check: v3 = const u64 0
 // check: v4 = get_elem_ptr v2, ptr u64, v3
-// check: store v1 to v4, !2
+// check: store v1 to v4,
 
 // ::check-ir-optimized::
 // pass: o1
diff --git a/test/src/ir_generation/tests/test_metadata.sw b/test/src/ir_generation/tests/test_metadata.sw
index 491a61a5e6a..f5811a1787f 100644
--- a/test/src/ir_generation/tests/test_metadata.sw
+++ b/test/src/ir_generation/tests/test_metadata.sw
@@ -11,5 +11,6 @@ fn my_test_func() {
 // check: fn main() -> (), $(main_md=$MD) {
 // check: fn my_test_func() -> (), $(test_md=$MD) {
 
+// check: $(fn_name_span_md=$MD) = fn_name_span $MD 52 64
 // check: $(decl_index_md=$MD) = decl_index
-// check: $test_md = ($MD $decl_index_md)
+// check: $test_md = ($MD $fn_name_span_md $decl_index_md)
diff --git a/test/src/main.rs b/test/src/main.rs
index 856b8e4728c..22a6c01c0e1 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -29,6 +29,14 @@ struct Cli {
     #[arg(long, visible_alias = "abi")]
     abi_only: bool,
 
+    /// Only run tests with no core dependencies
+    #[arg(long, visible_alias = "exclude_core")]
+    exclude_core: bool,
+
+    /// Only run tests with no std dependencies
+    #[arg(long, visible_alias = "exclude_std")]
+    exclude_std: bool,
+
     /// Only run tests that deploy contracts
     #[arg(long, visible_alias = "contract")]
     contract_only: bool,
@@ -80,6 +88,8 @@ pub struct FilterConfig {
     pub exclude: Option<regex::Regex>,
     pub skip_until: Option<regex::Regex>,
     pub abi_only: bool,
+    pub exclude_core: bool,
+    pub exclude_std: bool,
     pub contract_only: bool,
     pub first_only: bool,
 }
@@ -108,6 +118,8 @@ async fn main() -> Result<()> {
         exclude: cli.exclude,
         skip_until: cli.skip_until,
         abi_only: cli.abi_only,
+        exclude_core: cli.exclude_core,
+        exclude_std: cli.exclude_std,
         contract_only: cli.contract_only,
         first_only: cli.first_only,
     };
@@ -163,5 +175,13 @@ async fn main() -> Result<()> {
         .await?;
     }
 
+    // Run snapshot tests
+    let args = vec!["t", "--release", "-p", "test"];
+    let mut t = std::process::Command::new("cargo")
+        .args(args)
+        .spawn()
+        .unwrap();
+    assert!(t.wait().unwrap().success());
+
     Ok(())
 }
diff --git a/test/src/sdk-harness/Cargo.lock b/test/src/sdk-harness/Cargo.lock
index 81c7d47a9d4..dad11fa0e14 100644
--- a/test/src/sdk-harness/Cargo.lock
+++ b/test/src/sdk-harness/Cargo.lock
@@ -159,6 +159,12 @@ version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "25bdb32cbbdce2b519a9cd7df3a678443100e265d5e25ca763b7572a5104f5f3"
 
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+
 [[package]]
 name = "arrayref"
 version = "0.3.7"
@@ -230,21 +236,22 @@ checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
 
 [[package]]
 name = "async-graphql"
-version = "4.0.16"
+version = "7.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9ed522678d412d77effe47b3c82314ac36952a35e6e852093dd48287c421f80"
+checksum = "0ba6d24703c5adc5ba9116901b92ee4e4c0643c01a56c4fd303f3818638d7449"
 dependencies = [
  "async-graphql-derive",
  "async-graphql-parser",
  "async-graphql-value",
  "async-stream",
  "async-trait",
- "base64 0.13.1",
+ "base64 0.22.1",
  "bytes",
  "fnv",
+ "futures-timer",
  "futures-util",
- "http",
- "indexmap 1.9.3",
+ "http 1.1.0",
+ "indexmap 2.2.6",
  "mime",
  "multer",
  "num-traits",
@@ -254,8 +261,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
- "static_assertions",
- "tempfile",
+ "static_assertions_next",
  "thiserror",
  "tracing",
  "tracing-futures",
@@ -263,25 +269,26 @@ dependencies = [
 
 [[package]]
 name = "async-graphql-derive"
-version = "4.0.16"
+version = "7.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c121a894495d7d3fc3d4e15e0a9843e422e4d1d9e3c514d8062a1c94b35b005d"
+checksum = "a94c2d176893486bd37cd1b6defadd999f7357bf5804e92f510c08bcf16c538f"
 dependencies = [
  "Inflector",
  "async-graphql-parser",
- "darling 0.14.4",
- "proc-macro-crate 1.3.1",
+ "darling 0.20.10",
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "strum 0.26.3",
+ "syn 2.0.63",
  "thiserror",
 ]
 
 [[package]]
 name = "async-graphql-parser"
-version = "4.0.16"
+version = "7.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b6c386f398145c6180206c1869c2279f5a3d45db5be4e0266148c6ac5c6ad68"
+checksum = "79272bdbf26af97866e149f05b2b546edb5c00e51b5f916289931ed233e208ad"
 dependencies = [
  "async-graphql-value",
  "pest",
@@ -291,12 +298,12 @@ dependencies = [
 
 [[package]]
 name = "async-graphql-value"
-version = "4.0.16"
+version = "7.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a941b499fead4a3fb5392cabf42446566d18c86313f69f2deab69560394d65f"
+checksum = "ef5ec94176a12a8cbe985cd73f2e54dc9c702c88c766bdef12f1f3a67cedbee1"
 dependencies = [
  "bytes",
- "indexmap 1.9.3",
+ "indexmap 2.2.6",
  "serde",
  "serde_json",
 ]
@@ -405,7 +412,7 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d9a9bf8b79a749ee0b911b91b671cc2b6c670bdbc7e3dfd537576ddc94bb2a2"
 dependencies = [
- "http",
+ "http 0.2.12",
  "log",
  "url",
 ]
@@ -427,7 +434,7 @@ dependencies = [
  "bitflags 1.3.2",
  "bytes",
  "futures-util",
- "http",
+ "http 0.2.12",
  "http-body",
  "hyper",
  "itoa",
@@ -442,7 +449,7 @@ dependencies = [
  "sync_wrapper",
  "tokio",
  "tower",
- "tower-http",
+ "tower-http 0.3.5",
  "tower-layer",
  "tower-service",
 ]
@@ -456,7 +463,7 @@ dependencies = [
  "async-trait",
  "bytes",
  "futures-util",
- "http",
+ "http 0.2.12",
  "http-body",
  "mime",
  "tower-layer",
@@ -474,7 +481,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "miniz_oxide",
- "object",
+ "object 0.32.2",
  "rustc-demangle",
  "serde",
 ]
@@ -611,6 +618,11 @@ name = "cc"
 version = "1.0.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "099a5357d84c4c61eb35fc8eafa9a79a902c2f76911e5747ced4e032edd8d9b4"
+dependencies = [
+ "jobserver",
+ "libc",
+ "once_cell",
+]
 
 [[package]]
 name = "cfg-if"
@@ -890,6 +902,137 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cranelift-bforest"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "305d51c180ebdc46ef61bc60c54ae6512db3bc9a05842a1f1e762e45977019ab"
+dependencies = [
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-bitset"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3247afacd9b13d620033f3190d9e49d1beefc1acb33d5604a249956c9c13709"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "cranelift-codegen"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd7ca95e831c18d1356da783765c344207cbdffea91e13e47fa9327dbb2e0719"
+dependencies = [
+ "bumpalo",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-isle",
+ "gimli",
+ "hashbrown 0.14.5",
+ "log",
+ "regalloc2",
+ "rustc-hash",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "450c105fa1e51bfba4e95a86e926504a867ad5639d63f31d43fe3b7ec1f1c9ef"
+dependencies = [
+ "cranelift-codegen-shared",
+]
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5479117cd1266881479908d383086561cee37e49affbea9b1e6b594cc21cc220"
+
+[[package]]
+name = "cranelift-control"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34378804f0abfdd22c068a741cfeed86938b92375b2a96fb0b42c878e0141bfb"
+dependencies = [
+ "arbitrary",
+]
+
+[[package]]
+name = "cranelift-entity"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a48cb0a194c9ba82fec35a1e492055388d89b2e3c03dee9dcf2488892be8004d"
+dependencies = [
+ "cranelift-bitset",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "cranelift-frontend"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8327afc6c1c05f4be62fefce5b439fa83521c65363a322e86ea32c85e7ceaf64"
+dependencies = [
+ "cranelift-codegen",
+ "log",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-isle"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56b08621c00321efcfa3eee6a3179adc009e21ea8d24ca7adc3c326184bc3f48"
+
+[[package]]
+name = "cranelift-native"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51180b147c8557c1196c77b098f04140c91962e135ea152cd2fcabf40cf365c"
+dependencies = [
+ "cranelift-codegen",
+ "libc",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-wasm"
+version = "0.110.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "019e3dccb7f15e0bc14f0ddc034ec608a66df8e05c9e1e16f75a7716f8461799"
+dependencies = [
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "itertools 0.12.1",
+ "log",
+ "smallvec",
+ "wasmparser",
+ "wasmtime-types",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "critical-section"
 version = "1.1.2"
@@ -960,15 +1103,6 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "ct-logs"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1a816186fa68d9e426e3cb4ae4dff1fcd8e4a2c34b781bf7a822574a0d0aac8"
-dependencies = [
- "sct 0.6.1",
-]
-
 [[package]]
 name = "ctr"
 version = "0.9.2"
@@ -1058,22 +1192,12 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
-dependencies = [
- "darling_core 0.14.4",
- "darling_macro 0.14.4",
-]
-
-[[package]]
-name = "darling"
-version = "0.20.8"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core 0.20.8",
- "darling_macro 0.20.8",
+ "darling_core 0.20.10",
+ "darling_macro 0.20.10",
 ]
 
 [[package]]
@@ -1092,29 +1216,15 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim 0.10.0",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.20.8"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim 0.10.0",
+ "strsim 0.11.1",
  "syn 2.0.63",
 ]
 
@@ -1131,22 +1241,11 @@ dependencies = [
 
 [[package]]
 name = "darling_macro"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
-dependencies = [
- "darling_core 0.14.4",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "darling_macro"
-version = "0.20.8"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core 0.20.8",
+ "darling_core 0.20.10",
  "quote",
  "syn 2.0.63",
 ]
@@ -1268,6 +1367,27 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "directories-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.4"
@@ -1475,19 +1595,26 @@ dependencies = [
 
 [[package]]
 name = "eventsource-client"
-version = "0.10.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9146112ee3ce031aa5aebe3e049e10b1d353b9c7630cc6be488c2c62cc5d9c42"
+checksum = "43ddc25e1ad2cc0106d5e2d967397b4fb2068a66677ee9b0eea4600e5cfe8fb4"
 dependencies = [
  "futures",
  "hyper",
- "hyper-rustls 0.22.1",
+ "hyper-rustls",
  "hyper-timeout",
  "log",
  "pin-project",
+ "rand",
  "tokio",
 ]
 
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
 [[package]]
 name = "fastrand"
 version = "2.1.0"
@@ -1519,6 +1646,12 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
 [[package]]
 name = "float-cmp"
 version = "0.9.0"
@@ -1551,9 +1684,9 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
 
 [[package]]
 name = "fuel-abi-types"
-version = "0.5.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0e7e87f94417ff1a5d60e496906033c58bfe5367546621f131fe8cdabaa2671"
+checksum = "bce44ac13b1971be7cea024a2003cf944522093dafec454fea9ff792f0ff2577"
 dependencies = [
  "itertools 0.10.5",
  "lazy_static",
@@ -1568,33 +1701,59 @@ dependencies = [
 
 [[package]]
 name = "fuel-asm"
-version = "0.50.0"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "122c27ab46707017063bf1c6e0b4f3de881e22e81b4059750a0dc95033d9cc26"
+dependencies = [
+ "bitflags 2.5.0",
+ "fuel-types 0.56.0",
+ "serde",
+ "strum 0.24.1",
+]
+
+[[package]]
+name = "fuel-asm"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db81c0bdf07b052d1c595b5ee71e20f0286ca3dc88c7ab3f775e08c8e055c34f"
+checksum = "5f325971bf9047ec70004f80a989e03456316bc19cbef3ff3a39a38b192ab56e"
 dependencies = [
  "bitflags 2.5.0",
- "fuel-types",
+ "fuel-types 0.58.2",
  "serde",
  "strum 0.24.1",
 ]
 
+[[package]]
+name = "fuel-compression"
+version = "0.58.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24e42841f56f76ed759b3f516e5188d5c42de47015bee951651660c13b6dfa6c"
+dependencies = [
+ "fuel-derive 0.58.2",
+ "fuel-types 0.58.2",
+ "serde",
+]
+
 [[package]]
 name = "fuel-core"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ecef9aa6c04239c408e37613eb542f81cabb3a10a619b9c793312d38eed9e34"
+checksum = "9d5873aa1178f6fafdd967ddee2214a78be8be0c612a9c695889d31b5c1ede44"
 dependencies = [
  "anyhow",
  "async-graphql",
+ "async-graphql-value",
  "async-trait",
  "axum",
  "clap",
  "derive_more",
  "enum-iterator",
  "fuel-core-chain-config",
+ "fuel-core-compression",
  "fuel-core-consensus-module",
  "fuel-core-database",
  "fuel-core-executor",
+ "fuel-core-gas-price-service",
  "fuel-core-importer",
  "fuel-core-metrics",
  "fuel-core-p2p",
@@ -1603,13 +1762,14 @@ dependencies = [
  "fuel-core-services",
  "fuel-core-storage",
  "fuel-core-txpool",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "fuel-core-upgradable-executor",
  "futures",
  "hex",
  "hyper",
  "indicatif",
  "itertools 0.12.1",
+ "paste",
  "rand",
  "serde",
  "serde_json",
@@ -1617,24 +1777,26 @@ dependencies = [
  "strum_macros 0.25.3",
  "thiserror",
  "tokio",
+ "tokio-rayon",
  "tokio-stream",
  "tokio-util",
- "tower-http",
+ "tower",
+ "tower-http 0.4.4",
  "tracing",
  "uuid 1.8.0",
 ]
 
 [[package]]
 name = "fuel-core-chain-config"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16323762c4a5d58b11121580bee9f3a76ac7f655f95d727f957b05a9e35f477f"
+checksum = "990db3029efd3766c4ae7c92a53c159ae66abf6f568ac6a3d58354f11400e6e2"
 dependencies = [
  "anyhow",
  "bech32",
  "derivative",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "itertools 0.12.1",
  "postcard",
  "rand",
@@ -1646,18 +1808,19 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-client"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f33af785942254f23e30a03a08a08ffb8eea645a87f06895e5d84f4205fc191a"
+checksum = "f09b3a35e82226d77b10653829beb508dc4bcf698fbdaa96610faf894e794444"
 dependencies = [
  "anyhow",
+ "base64 0.22.1",
  "cynic",
  "derive_more",
  "eventsource-client",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "futures",
  "hex",
- "hyper-rustls 0.24.2",
+ "hyper-rustls",
  "itertools 0.12.1",
  "reqwest",
  "schemafy_lib",
@@ -1668,81 +1831,125 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "fuel-core-compression"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b6ed44f8fcd0f1ff5983510e49835149b39afb8226257f6397db17a0ca0558d"
+dependencies = [
+ "anyhow",
+ "fuel-core-types 0.40.0",
+ "paste",
+ "rand",
+ "serde",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+]
+
 [[package]]
 name = "fuel-core-consensus-module"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85320bb1990ea54ad9fcda4c527c2e42651103c2332cb7ff0b51ecaa23b4c07a"
+checksum = "61161b1016ffb1a4f0d629534dd0b165bdaf146ce5037ccd5c8e8c9ec740d52f"
 dependencies = [
  "anyhow",
  "fuel-core-chain-config",
  "fuel-core-poa",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
 ]
 
 [[package]]
 name = "fuel-core-database"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540b36b409d36ace39902509d55d0c758f9cfebc1bcbea07d7115b9923196c9"
+checksum = "ceae011a49cbccb0e9b043c67f7e64dfd2f4d41233de34aff11d23646e98f5d8"
 dependencies = [
  "anyhow",
  "derive_more",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
 ]
 
 [[package]]
 name = "fuel-core-executor"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "367ef0966c99cf1104035257023596256d61a3a5b58b8bac4dcb0bdc8e9b2459"
+checksum = "db57f06af045fafa81b76ca11318d47579e41babb0839fb0955ae7cf32e58a1f"
 dependencies = [
  "anyhow",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "hex",
  "parking_lot",
  "serde",
  "tracing",
 ]
 
+[[package]]
+name = "fuel-core-gas-price-service"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eea974f842be1ca7783df7eec770b5865c3babd50a10a5d8f107bdac65419c45"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "enum-iterator",
+ "fuel-core-services",
+ "fuel-core-storage",
+ "fuel-core-types 0.40.0",
+ "fuel-gas-price-algorithm",
+ "futures",
+ "num_enum",
+ "parking_lot",
+ "reqwest",
+ "serde",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
+ "thiserror",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+]
+
 [[package]]
 name = "fuel-core-importer"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7c89083930099a8dad11f5602d4bd935ff5db546ba600cbb9325f6b3bd78ac"
+checksum = "2a6a75d87da09380dc6f706ec0eb4171cb1309fef6a4c8b709025769a1903235"
 dependencies = [
  "anyhow",
  "derive_more",
  "fuel-core-metrics",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
+ "parking_lot",
+ "rayon",
  "tokio",
- "tokio-rayon",
  "tracing",
 ]
 
 [[package]]
 name = "fuel-core-metrics"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a47f442a32f2e5917066bbf9be3d6fd5d85252a131f1b5fc2f2f0ee75008066"
+checksum = "94a1c3eb92040d95d27f7c658801bb5c04ad4aaf67de380cececbeed5aab6e61"
 dependencies = [
- "axum",
  "once_cell",
+ "parking_lot",
  "pin-project-lite",
  "prometheus-client",
  "regex",
+ "strum 0.25.0",
+ "strum_macros 0.25.3",
  "tracing",
 ]
 
 [[package]]
 name = "fuel-core-p2p"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc6a321f2b1df5be84444ee8b12b647313a5b92a2589d06489bb2b00dbdb2e1"
+checksum = "db5c996b4d392a5f1991b4d2fcc2fe570dc846f8a763a30105cd7b3c8d08e747"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1750,9 +1957,10 @@ dependencies = [
  "fuel-core-metrics",
  "fuel-core-services",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "futures",
  "hex",
+ "hickory-resolver",
  "ip_network",
  "libp2p",
  "libp2p-mplex",
@@ -1761,6 +1969,7 @@ dependencies = [
  "quick-protobuf",
  "quick-protobuf-codec",
  "rand",
+ "rayon",
  "serde",
  "serde_with",
  "sha2 0.10.8",
@@ -1772,16 +1981,18 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-poa"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f6185f492f9ddb65228db0f250b3f6384637ebf76b72fc81b2efb629d887912"
+checksum = "2f6f78fa31dc56b9458e3ca9a7058b4bea381e16e49fcab0db49923be8a30f9c"
 dependencies = [
  "anyhow",
  "async-trait",
  "fuel-core-chain-config",
  "fuel-core-services",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
+ "serde",
+ "serde_json",
  "tokio",
  "tokio-stream",
  "tracing",
@@ -1789,15 +2000,15 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-producer"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efad4ce5bc2f4542e3838a4256158fdd7c537d73e359ba589a4ea86e5c8a2ee0"
+checksum = "7739b2019df5b9d5042ba2d9f7036c6feee105a0e441d8bcfd933221da5be635"
 dependencies = [
  "anyhow",
  "async-trait",
  "derive_more",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "tokio",
  "tokio-rayon",
  "tracing",
@@ -1805,30 +2016,32 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-services"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d35200489fdcdafbe5a6a3a39baad4da523e5c004db9a885056be0137ee35098"
+checksum = "8312b598da4b9a6503c9263c1c2a7ea58d34ab1f86e7f345490e12d309fb29bb"
 dependencies = [
  "anyhow",
  "async-trait",
  "fuel-core-metrics",
  "futures",
  "parking_lot",
+ "pin-project-lite",
+ "rayon",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "fuel-core-storage"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4e85b634f42fb53193da517b4a2efa8ac73031cdab653029a5b1d3725572d"
+checksum = "bda9242ebc9e8ef3251b9eae85f4ce5cdb376348baa30925606f3ce602db7ec5"
 dependencies = [
  "anyhow",
  "derive_more",
  "enum-iterator",
- "fuel-core-types",
- "fuel-vm",
+ "fuel-core-types 0.40.0",
+ "fuel-vm 0.58.2",
  "impl-tools",
  "itertools 0.12.1",
  "mockall",
@@ -1844,66 +2057,120 @@ dependencies = [
 
 [[package]]
 name = "fuel-core-txpool"
-version = "0.27.0"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "800ab382b81de3fa62858862acb25410fdba514fae9b3862065524ac25244678"
+checksum = "34cde90da8d814046018c5341129bffdbc51e6721e69ada9a393b3d4c16be14b"
 dependencies = [
  "anyhow",
  "async-trait",
- "fuel-core-metrics",
+ "derive_more",
  "fuel-core-services",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.40.0",
  "futures",
- "mockall",
+ "num-rational",
  "parking_lot",
+ "petgraph",
  "tokio",
- "tokio-rayon",
  "tokio-stream",
  "tracing",
 ]
 
 [[package]]
 name = "fuel-core-types"
-version = "0.27.0"
+version = "0.35.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84fda0c6dc7b3bd24a993b3902f55862b8db0fa6de5b0f1d45f5942bc59792eb"
+dependencies = [
+ "anyhow",
+ "derivative",
+ "derive_more",
+ "fuel-vm 0.56.0",
+ "secrecy",
+ "serde",
+ "tai64",
+ "zeroize",
+]
+
+[[package]]
+name = "fuel-core-types"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffe21004dd036f4c454666e339bd0fc3b037535bbc5510321db2565087edd4fc"
+checksum = "6ee3a95b189bf729d21354a761862bb481298cbd883550adc3fef1bc7beb0b67"
 dependencies = [
  "anyhow",
  "bs58",
  "derivative",
  "derive_more",
- "fuel-vm",
+ "fuel-vm 0.58.2",
  "rand",
  "secrecy",
  "serde",
  "tai64",
- "thiserror",
  "zeroize",
 ]
 
 [[package]]
 name = "fuel-core-upgradable-executor"
-version = "0.27.0"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "620b671cd011ee14c846628ca0d913b770923b36fd87d44dd7ba70f1a8db0eec"
+dependencies = [
+ "anyhow",
+ "derive_more",
+ "fuel-core-executor",
+ "fuel-core-storage",
+ "fuel-core-types 0.40.0",
+ "fuel-core-wasm-executor",
+ "parking_lot",
+ "postcard",
+ "tracing",
+ "wasmtime",
+]
+
+[[package]]
+name = "fuel-core-wasm-executor"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7136365b6d48f78ea5ce6bbd3c3c79dece5777ec13a9b63ef4f56abeab6017e"
+checksum = "b44366541d35be9ea11ed88ed54629c64e91c309ca5fbf861fd909d443ca7575"
 dependencies = [
+ "anyhow",
  "fuel-core-executor",
  "fuel-core-storage",
- "fuel-core-types",
+ "fuel-core-types 0.35.0",
+ "fuel-core-types 0.40.0",
+ "postcard",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
 name = "fuel-crypto"
-version = "0.50.0"
+version = "0.56.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca73b3409086e772315625304cabd2eeec10e4bd1f8b8a99cc72e0aed755e5c"
+checksum = "33548590131674e8f272a3e056be4dbaa1de7cb364eab2b17987cd5c0dc31cb0"
+dependencies = [
+ "ecdsa",
+ "ed25519-dalek",
+ "fuel-types 0.56.0",
+ "k256",
+ "p256",
+ "serde",
+ "sha2 0.10.8",
+ "zeroize",
+]
+
+[[package]]
+name = "fuel-crypto"
+version = "0.58.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65e318850ca64890ff123a99b6b866954ef49da94ab9bc6827cf6ee045568585"
 dependencies = [
  "coins-bip32",
  "coins-bip39",
  "ecdsa",
  "ed25519-dalek",
- "fuel-types",
+ "fuel-types 0.58.2",
  "k256",
  "lazy_static",
  "p256",
@@ -1916,9 +2183,21 @@ dependencies = [
 
 [[package]]
 name = "fuel-derive"
-version = "0.50.0"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f49fdbfc1615d88d2849650afc2b0ac2fecd69661ebadd31a073d8416747764"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.63",
+ "synstructure 0.13.1",
+]
+
+[[package]]
+name = "fuel-derive"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8d6e66d1b68eb916640c12a1c6c40880e11fcf569359b04483d5e18237c5229"
+checksum = "ab0bc46a3552964bae5169e79b383761a54bd115ea66951a1a7a229edcefa55a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1926,15 +2205,40 @@ dependencies = [
  "synstructure 0.13.1",
 ]
 
+[[package]]
+name = "fuel-gas-price-algorithm"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b51715a07bb4a099ca4c658796c7a732f3edb3dfb2cec3407769081c949dc0b"
+dependencies = [
+ "serde",
+ "thiserror",
+]
+
 [[package]]
 name = "fuel-merkle"
-version = "0.50.0"
+version = "0.56.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "faa4b60ddfa51b64d02a1d71b0cf51488171d313b32ae3fb9f39f64ddd21791b"
+checksum = "cf17ce8ee5e8b573ea584c223635ff09f1288ad022bcf662954fdccb907602eb"
 dependencies = [
  "derive_more",
  "digest 0.10.7",
- "fuel-storage",
+ "fuel-storage 0.56.0",
+ "hashbrown 0.13.2",
+ "hex",
+ "serde",
+ "sha2 0.10.8",
+]
+
+[[package]]
+name = "fuel-merkle"
+version = "0.58.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c79eca6a452311c70978a5df796c0f99f27e474b69719e0db4c1d82e68800d07"
+dependencies = [
+ "derive_more",
+ "digest 0.10.7",
+ "fuel-storage 0.58.2",
  "hashbrown 0.13.2",
  "hex",
  "serde",
@@ -1943,40 +2247,79 @@ dependencies = [
 
 [[package]]
 name = "fuel-storage"
-version = "0.50.0"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c1b711f28553ddc5f3546711bd220e144ce4c1af7d9e9a1f70b2f20d9f5b791"
+
+[[package]]
+name = "fuel-storage"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beef5f12c40118e87ef6abf611c6bba5c88754e727fb825120ae7d0872123055"
+checksum = "2d0c46b5d76b3e11197bd31e036cd8b1cb46c4d822cacc48836638080c6d2b76"
 
 [[package]]
 name = "fuel-tx"
-version = "0.50.0"
+version = "0.56.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95857e761db34a50967f53af7a74be08130d210bd985c5585f36bd753d346c"
+checksum = "13aae44611588d199dd119e4a0ebd8eb7ae4cde6bf8b4d12715610b1f5e5b731"
 dependencies = [
  "bitflags 2.5.0",
  "derivative",
  "derive_more",
- "fuel-asm",
- "fuel-crypto",
- "fuel-merkle",
- "fuel-types",
+ "fuel-asm 0.56.0",
+ "fuel-crypto 0.56.0",
+ "fuel-merkle 0.56.0",
+ "fuel-types 0.56.0",
  "hashbrown 0.14.5",
  "itertools 0.10.5",
  "postcard",
- "rand",
  "serde",
  "serde_json",
  "strum 0.24.1",
  "strum_macros 0.24.3",
 ]
 
+[[package]]
+name = "fuel-tx"
+version = "0.58.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6723bb8710ba2b70516ac94d34459593225870c937670fb3afaf82e0354667ac"
+dependencies = [
+ "bitflags 2.5.0",
+ "derivative",
+ "derive_more",
+ "fuel-asm 0.58.2",
+ "fuel-compression",
+ "fuel-crypto 0.58.2",
+ "fuel-merkle 0.58.2",
+ "fuel-types 0.58.2",
+ "hashbrown 0.14.5",
+ "itertools 0.10.5",
+ "postcard",
+ "rand",
+ "serde",
+ "strum 0.24.1",
+ "strum_macros 0.24.3",
+]
+
 [[package]]
 name = "fuel-types"
-version = "0.50.0"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b6fb26bcb408b6897e603f68cf60bbbaf6d15381c99f54a69ea743a58235ac1"
+dependencies = [
+ "fuel-derive 0.56.0",
+ "hex",
+ "serde",
+]
+
+[[package]]
+name = "fuel-types"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0af9f9d8c9eb3f4e644731c829ee7da5c3cae0886864731089627af25e336cea"
+checksum = "982265415a99b5bd6277bc24194a233bb2e18764df11c937b3dbb11a02c9e545"
 dependencies = [
- "fuel-derive",
+ "fuel-derive 0.58.2",
  "hex",
  "rand",
  "serde",
@@ -1984,9 +2327,40 @@ dependencies = [
 
 [[package]]
 name = "fuel-vm"
-version = "0.50.0"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64fc4695efac9207276f6229f2dd9811848b328a13604a698f7bce1d452bd986"
+dependencies = [
+ "async-trait",
+ "backtrace",
+ "bitflags 2.5.0",
+ "derivative",
+ "derive_more",
+ "ethnum",
+ "fuel-asm 0.56.0",
+ "fuel-crypto 0.56.0",
+ "fuel-merkle 0.56.0",
+ "fuel-storage 0.56.0",
+ "fuel-tx 0.56.0",
+ "fuel-types 0.56.0",
+ "hashbrown 0.14.5",
+ "itertools 0.10.5",
+ "libm",
+ "paste",
+ "percent-encoding",
+ "primitive-types",
+ "serde",
+ "serde_with",
+ "sha3",
+ "static_assertions",
+ "strum 0.24.1",
+]
+
+[[package]]
+name = "fuel-vm"
+version = "0.58.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71df1a9ede5237febbc7864888f26365814327732ccd11002e9bddac1ce9a4e6"
+checksum = "54b5362d7d072c72eec20581f67fc5400090c356a7f3ae77c79880b3b177b667"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1995,12 +2369,13 @@ dependencies = [
  "derivative",
  "derive_more",
  "ethnum",
- "fuel-asm",
- "fuel-crypto",
- "fuel-merkle",
- "fuel-storage",
- "fuel-tx",
- "fuel-types",
+ "fuel-asm 0.58.2",
+ "fuel-compression",
+ "fuel-crypto 0.58.2",
+ "fuel-merkle 0.58.2",
+ "fuel-storage 0.58.2",
+ "fuel-tx 0.58.2",
+ "fuel-types 0.58.2",
  "hashbrown 0.14.5",
  "itertools 0.10.5",
  "libm",
@@ -2018,14 +2393,13 @@ dependencies = [
 
 [[package]]
 name = "fuels"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e318b107e6fef3d786f2366cc78a6314a6b326342d375203238f130a7356fe49"
+checksum = "6ed08053e72bdb285d5a167c27a7a0d10f1dc4e27d1e6e5296dd2a67813bd13f"
 dependencies = [
- "fuel-core",
  "fuel-core-client",
- "fuel-crypto",
- "fuel-tx",
+ "fuel-crypto 0.58.2",
+ "fuel-tx 0.58.2",
  "fuels-accounts",
  "fuels-core",
  "fuels-macros",
@@ -2035,20 +2409,22 @@ dependencies = [
 
 [[package]]
 name = "fuels-accounts"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e17d23b925d3d5e21dc5428330695c596db356d4adfc90eadecc2a490d7d5ce"
+checksum = "49fee90e8f3a4fc9392a6cde3010c561fa50da0f805d66fdb659eaa4d5d8a504"
 dependencies = [
  "async-trait",
  "chrono",
+ "cynic",
  "elliptic-curve",
  "eth-keystore",
  "fuel-core-client",
- "fuel-core-types",
- "fuel-crypto",
- "fuel-tx",
- "fuel-types",
+ "fuel-core-types 0.40.0",
+ "fuel-crypto 0.58.2",
+ "fuel-tx 0.58.2",
+ "fuel-types 0.58.2",
  "fuels-core",
+ "itertools 0.12.1",
  "rand",
  "semver",
  "tai64",
@@ -2059,9 +2435,9 @@ dependencies = [
 
 [[package]]
 name = "fuels-code-gen"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86a7a5b4811f5563bb5c2485efc7653ed6ce465c452a1182ae9062aa13dd19af"
+checksum = "f857b7ff658400506ca6be57bb84fedda44b566e78f5f0a8d0782242f41615c0"
 dependencies = [
  "Inflector",
  "fuel-abi-types",
@@ -2075,37 +2451,38 @@ dependencies = [
 
 [[package]]
 name = "fuels-core"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9774ae9b35f808fa18b92d0478a3b0acbea41011409efa3117f972dfe528ae09"
+checksum = "baccbdd81e624f57950dcb136b32b853c520dd954badf26b9f58de33f3d71c7e"
 dependencies = [
  "async-trait",
  "bech32",
  "chrono",
  "fuel-abi-types",
- "fuel-asm",
+ "fuel-asm 0.58.2",
  "fuel-core-chain-config",
  "fuel-core-client",
- "fuel-core-types",
- "fuel-crypto",
- "fuel-tx",
- "fuel-types",
- "fuel-vm",
+ "fuel-core-types 0.40.0",
+ "fuel-crypto 0.58.2",
+ "fuel-tx 0.58.2",
+ "fuel-types 0.58.2",
+ "fuel-vm 0.58.2",
  "fuels-macros",
  "hex",
  "itertools 0.12.1",
  "postcard",
  "serde",
  "serde_json",
+ "sha2 0.10.8",
  "thiserror",
  "uint",
 ]
 
 [[package]]
 name = "fuels-macros"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba92a701fa86eed843db68d991807207b8b3d47099d49fb82467e8900f680e01"
+checksum = "5da75294c5e9da312bdc49239736699ee84ea9c5bfbc19a61a8ee588a1247aa1"
 dependencies = [
  "fuels-code-gen",
  "itertools 0.12.1",
@@ -2116,15 +2493,15 @@ dependencies = [
 
 [[package]]
 name = "fuels-programs"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6c72ac2f1cdda800dbc1c3714459f83bf208cef78812448992b6dbdda6841dc"
+checksum = "32675ed1c08edd28ddb648dfae0c60a1946d4368a69ddfa6434f2316e33f0520"
 dependencies = [
  "async-trait",
  "fuel-abi-types",
- "fuel-asm",
- "fuel-tx",
- "fuel-types",
+ "fuel-asm 0.58.2",
+ "fuel-tx 0.58.2",
+ "fuel-types 0.58.2",
  "fuels-accounts",
  "fuels-core",
  "itertools 0.12.1",
@@ -2135,19 +2512,19 @@ dependencies = [
 
 [[package]]
 name = "fuels-test-helpers"
-version = "0.63.0"
+version = "0.66.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b8a632f2b4ddb52e8ad92871f63521e9f5cc299f842a3207f3655acc21c148"
+checksum = "02176c0fb1bf8cf58b8a9e5372efb650324740abcd4847b45bd0b041a0f133a2"
 dependencies = [
  "fuel-core",
  "fuel-core-chain-config",
  "fuel-core-client",
  "fuel-core-poa",
  "fuel-core-services",
- "fuel-core-types",
- "fuel-crypto",
- "fuel-tx",
- "fuel-types",
+ "fuel-core-types 0.40.0",
+ "fuel-crypto 0.58.2",
+ "fuel-tx 0.58.2",
+ "fuel-types 0.58.2",
  "fuels-accounts",
  "fuels-core",
  "futures",
@@ -2251,7 +2628,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35bd3cf68c183738046838e300353e4716c674dc5e56890de4826801a6622a28"
 dependencies = [
  "futures-io",
- "rustls 0.21.12",
+ "rustls",
 ]
 
 [[package]]
@@ -2338,6 +2715,11 @@ name = "gimli"
 version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+dependencies = [
+ "fallible-iterator",
+ "indexmap 2.2.6",
+ "stable_deref_trait",
+]
 
 [[package]]
 name = "graphql-parser"
@@ -2371,7 +2753,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "futures-util",
- "http",
+ "http 0.2.12",
  "indexmap 2.2.6",
  "slab",
  "tokio",
@@ -2577,6 +2959,17 @@ dependencies = [
  "itoa",
 ]
 
+[[package]]
+name = "http"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
 [[package]]
 name = "http-body"
 version = "0.4.6"
@@ -2584,7 +2977,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
  "bytes",
- "http",
+ "http 0.2.12",
  "pin-project-lite",
 ]
 
@@ -2617,7 +3010,7 @@ dependencies = [
  "futures-core",
  "futures-util",
  "h2",
- "http",
+ "http 0.2.12",
  "http-body",
  "httparse",
  "httpdate",
@@ -2630,23 +3023,6 @@ dependencies = [
  "want",
 ]
 
-[[package]]
-name = "hyper-rustls"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f9f7a97316d44c0af9b0301e65010573a853a9fc97046d7331d7f6bc0fd5a64"
-dependencies = [
- "ct-logs",
- "futures-util",
- "hyper",
- "log",
- "rustls 0.19.1",
- "rustls-native-certs 0.5.0",
- "tokio",
- "tokio-rustls 0.22.0",
- "webpki",
-]
-
 [[package]]
 name = "hyper-rustls"
 version = "0.24.2"
@@ -2654,13 +3030,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
- "http",
+ "http 0.2.12",
  "hyper",
  "log",
- "rustls 0.21.12",
- "rustls-native-certs 0.6.3",
+ "rustls",
+ "rustls-native-certs",
  "tokio",
- "tokio-rustls 0.24.1",
+ "tokio-rustls",
  "webpki-roots",
 ]
 
@@ -2699,6 +3075,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "id-arena"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -2774,7 +3156,7 @@ dependencies = [
  "attohttpc",
  "bytes",
  "futures",
- "http",
+ "http 0.2.12",
  "hyper",
  "log",
  "rand",
@@ -2914,6 +3296,15 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "jobserver"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.69"
@@ -2952,6 +3343,12 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
+[[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
 [[package]]
 name = "libc"
 version = "0.2.154"
@@ -3272,7 +3669,7 @@ dependencies = [
  "quinn",
  "rand",
  "ring 0.16.20",
- "rustls 0.21.12",
+ "rustls",
  "socket2",
  "thiserror",
  "tokio",
@@ -3364,7 +3761,7 @@ dependencies = [
  "libp2p-identity",
  "rcgen",
  "ring 0.16.20",
- "rustls 0.21.12",
+ "rustls",
  "rustls-webpki",
  "thiserror",
  "x509-parser",
@@ -3422,6 +3819,16 @@ dependencies = [
  "yamux 0.13.2",
 ]
 
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+]
+
 [[package]]
 name = "libsecp256k1"
 version = "0.7.1"
@@ -3516,6 +3923,15 @@ dependencies = [
  "linked-hash-map",
 ]
 
+[[package]]
+name = "mach2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "match_cfg"
 version = "0.1.0"
@@ -3534,6 +3950,15 @@ version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
 
+[[package]]
+name = "memfd"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2cffa4ad52c6f791f4f8b15f0c05f9824b2ced1160e88cc393d64fff9a8ac64"
+dependencies = [
+ "rustix",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -3595,16 +4020,15 @@ dependencies = [
 
 [[package]]
 name = "multer"
-version = "2.1.0"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01acbdc23469fd8fe07ab135923371d5f5a422fbf9c522158677c8eb15bc51c2"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
 dependencies = [
  "bytes",
  "encoding_rs",
  "futures-util",
- "http",
+ "http 1.1.0",
  "httparse",
- "log",
  "memchr",
  "mime",
  "spin 0.9.8",
@@ -3789,6 +4213,17 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -3823,7 +4258,7 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
 dependencies = [
- "proc-macro-crate 3.1.0",
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn 2.0.63",
@@ -3844,6 +4279,18 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "object"
+version = "0.36.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
+dependencies = [
+ "crc32fast",
+ "hashbrown 0.14.5",
+ "indexmap 2.2.6",
+ "memchr",
+]
+
 [[package]]
 name = "oid-registry"
 version = "0.6.1"
@@ -3955,15 +4402,25 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.7.10"
+version = "2.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
+checksum = "fdbef9d1d47087a895abd220ed25eb4ad973a5e26f6a4367b038c25e28dfc2d9"
 dependencies = [
  "memchr",
  "thiserror",
  "ucd-trie",
 ]
 
+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap 2.2.6",
+]
+
 [[package]]
 name = "pin-project"
 version = "1.1.5"
@@ -4006,6 +4463,12 @@ dependencies = [
  "spki",
 ]
 
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
 [[package]]
 name = "platforms"
 version = "3.4.0"
@@ -4148,16 +4611,6 @@ dependencies = [
  "uint",
 ]
 
-[[package]]
-name = "proc-macro-crate"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
-dependencies = [
- "once_cell",
- "toml_edit 0.19.15",
-]
-
 [[package]]
 name = "proc-macro-crate"
 version = "3.1.0"
@@ -4228,6 +4681,15 @@ version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac"
 
+[[package]]
+name = "psm"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa37f80ca58604976033fae9515a8a2989fc13797d953f7c04fb8fa36a11f205"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "publicsuffix"
 version = "2.2.3"
@@ -4278,7 +4740,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls 0.21.12",
+ "rustls",
  "thiserror",
  "tokio",
  "tracing",
@@ -4294,7 +4756,7 @@ dependencies = [
  "rand",
  "ring 0.16.20",
  "rustc-hash",
- "rustls 0.21.12",
+ "rustls",
  "slab",
  "thiserror",
  "tinyvec",
@@ -4400,6 +4862,30 @@ dependencies = [
  "bitflags 2.5.0",
 ]
 
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom",
+ "libredox",
+ "thiserror",
+]
+
+[[package]]
+name = "regalloc2"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6"
+dependencies = [
+ "hashbrown 0.13.2",
+ "log",
+ "rustc-hash",
+ "slice-group-by",
+ "smallvec",
+]
+
 [[package]]
 name = "regex"
 version = "1.10.4"
@@ -4443,10 +4929,10 @@ dependencies = [
  "futures-core",
  "futures-util",
  "h2",
- "http",
+ "http 0.2.12",
  "http-body",
  "hyper",
- "hyper-rustls 0.24.2",
+ "hyper-rustls",
  "ipnet",
  "js-sys",
  "log",
@@ -4454,7 +4940,7 @@ dependencies = [
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
- "rustls 0.21.12",
+ "rustls",
  "rustls-pemfile",
  "serde",
  "serde_json",
@@ -4462,7 +4948,7 @@ dependencies = [
  "sync_wrapper",
  "system-configuration",
  "tokio",
- "tokio-rustls 0.24.1",
+ "tokio-rustls",
  "tower-service",
  "url",
  "wasm-bindgen",
@@ -4589,19 +5075,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "rustls"
-version = "0.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35edb675feee39aec9c99fa5ff985081995a06d594114ae14cbe797ad7b7a6d7"
-dependencies = [
- "base64 0.13.1",
- "log",
- "ring 0.16.20",
- "sct 0.6.1",
- "webpki",
-]
-
 [[package]]
 name = "rustls"
 version = "0.21.12"
@@ -4611,19 +5084,7 @@ dependencies = [
  "log",
  "ring 0.17.8",
  "rustls-webpki",
- "sct 0.7.1",
-]
-
-[[package]]
-name = "rustls-native-certs"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a07b7c1885bd8ed3831c289b7870b13ef46fe0e856d288c30d9cc17d75a2092"
-dependencies = [
- "openssl-probe",
- "rustls 0.19.1",
- "schannel",
- "security-framework",
+ "sct",
 ]
 
 [[package]]
@@ -4744,22 +5205,12 @@ dependencies = [
 
 [[package]]
 name = "sct"
-version = "0.6.1"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring 0.16.20",
- "untrusted 0.7.1",
-]
-
-[[package]]
-name = "sct"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
-dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -4778,9 +5229,9 @@ dependencies = [
 
 [[package]]
 name = "secp256k1"
-version = "0.26.0"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4124a35fe33ae14259c490fd70fa199a32b9ce9502f2ee6bc4f81ec06fa65894"
+checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
 dependencies = [
  "rand",
  "secp256k1-sys",
@@ -4788,9 +5239,9 @@ dependencies = [
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.8.1"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70a129b9e9efbfb223753b9163c4ab3b13cff7fd9c7f010fbac25ab4099fa07e"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
 dependencies = [
  "cc",
 ]
@@ -4864,6 +5315,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
@@ -4900,7 +5360,7 @@ version = "3.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2"
 dependencies = [
- "darling 0.20.8",
+ "darling 0.20.10",
  "proc-macro2",
  "quote",
  "syn 2.0.63",
@@ -4981,11 +5441,20 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "slice-group-by"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
+
 [[package]]
 name = "smallvec"
 version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "snow"
@@ -5054,6 +5523,12 @@ dependencies = [
  "der",
 ]
 
+[[package]]
+name = "sptr"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9b39299b249ad65f3b7e96443bad61c02ca5cd3589f46cb6d610a0fd6c0d6a"
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -5066,6 +5541,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
+[[package]]
+name = "static_assertions_next"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7beae5182595e9a8b683fa98c4317f956c9a2dec3b9716990d20023cc60c766"
+
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -5096,6 +5577,15 @@ dependencies = [
  "strum_macros 0.25.3",
 ]
 
+[[package]]
+name = "strum"
+version = "0.26.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
+dependencies = [
+ "strum_macros 0.26.4",
+]
+
 [[package]]
 name = "strum_macros"
 version = "0.24.3"
@@ -5122,6 +5612,19 @@ dependencies = [
  "syn 2.0.63",
 ]
 
+[[package]]
+name = "strum_macros"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.63",
+]
+
 [[package]]
 name = "subtle"
 version = "2.5.0"
@@ -5215,6 +5718,12 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
 [[package]]
 name = "tempfile"
 version = "3.10.1"
@@ -5227,6 +5736,15 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "termtree"
 version = "0.4.1"
@@ -5240,7 +5758,7 @@ dependencies = [
  "assert_matches",
  "fuel-core",
  "fuel-core-client",
- "fuel-vm",
+ "fuel-vm 0.58.2",
  "fuels",
  "hex",
  "paste",
@@ -5368,24 +5886,13 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-rustls"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc6844de72e57df1980054b38be3a9f4702aba4858be64dd700181a8a6d0e1b6"
-dependencies = [
- "rustls 0.19.1",
- "tokio",
- "webpki",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
- "rustls 0.21.12",
+ "rustls",
  "tokio",
 ]
 
@@ -5414,32 +5921,49 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "toml"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.22.12",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "toml_edit"
-version = "0.19.15"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
  "indexmap 2.2.6",
  "toml_datetime",
- "winnow",
+ "winnow 0.5.40",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.21.1"
+version = "0.22.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
+checksum = "d3328d4f68a705b2a4498da1d580585d39a6510f98318a2cec3018a7ec61ddef"
 dependencies = [
  "indexmap 2.2.6",
+ "serde",
+ "serde_spanned",
  "toml_datetime",
- "winnow",
+ "winnow 0.6.18",
 ]
 
 [[package]]
@@ -5453,6 +5977,7 @@ dependencies = [
  "pin-project",
  "pin-project-lite",
  "tokio",
+ "tokio-util",
  "tower-layer",
  "tower-service",
  "tracing",
@@ -5468,14 +5993,32 @@ dependencies = [
  "bytes",
  "futures-core",
  "futures-util",
- "http",
+ "http 0.2.12",
  "http-body",
  "http-range-header",
  "pin-project-lite",
- "tokio",
  "tower",
  "tower-layer",
  "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c5bb1d698276a2443e5ecfabc1008bf15a36c12e6a7176e7bf089ea9131140"
+dependencies = [
+ "bitflags 2.5.0",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http 0.2.12",
+ "http-body",
+ "http-range-header",
+ "pin-project-lite",
+ "tokio",
+ "tower-layer",
+ "tower-service",
  "tracing",
 ]
 
@@ -5775,23 +6318,241 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
 
 [[package]]
-name = "web-sys"
-version = "0.3.69"
+name = "wasm-encoder"
+version = "0.212.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+checksum = "501940df4418b8929eb6d52f1aade1fdd15a5b86c92453cb696e3c906bd3fc33"
 dependencies = [
- "js-sys",
- "wasm-bindgen",
+ "leb128",
 ]
 
 [[package]]
-name = "webpki"
-version = "0.21.4"
+name = "wasmparser"
+version = "0.212.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea"
+checksum = "8d28bc49ba1e5c5b61ffa7a2eace10820443c4b7d1c0b144109261d14570fdf8"
 dependencies = [
- "ring 0.16.20",
- "untrusted 0.7.1",
+ "ahash",
+ "bitflags 2.5.0",
+ "hashbrown 0.14.5",
+ "indexmap 2.2.6",
+ "semver",
+ "serde",
+]
+
+[[package]]
+name = "wasmprinter"
+version = "0.212.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfac65326cc561112af88c3028f6dfdb140acff67ede33a8e86be2dc6b8956f7"
+dependencies = [
+ "anyhow",
+ "termcolor",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmtime"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07232e0b473af36112da7348f51e73fa8b11047a6cb546096da3812930b7c93a"
+dependencies = [
+ "anyhow",
+ "bitflags 2.5.0",
+ "bumpalo",
+ "cc",
+ "cfg-if",
+ "hashbrown 0.14.5",
+ "indexmap 2.2.6",
+ "libc",
+ "libm",
+ "log",
+ "mach2",
+ "memfd",
+ "object 0.36.4",
+ "once_cell",
+ "paste",
+ "postcard",
+ "psm",
+ "rayon",
+ "rustix",
+ "serde",
+ "serde_derive",
+ "smallvec",
+ "sptr",
+ "target-lexicon",
+ "wasmparser",
+ "wasmtime-asm-macros",
+ "wasmtime-cache",
+ "wasmtime-component-macro",
+ "wasmtime-cranelift",
+ "wasmtime-environ",
+ "wasmtime-jit-icache-coherence",
+ "wasmtime-slab",
+ "wasmtime-versioned-export-macros",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "wasmtime-asm-macros"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a9c42562d879c749288d9a26acc0d95d2ca069e30c2ec2efce84461c4d62b3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "wasmtime-cache"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d5d5aac98c8ae87cf5244495da7722e3fa022aa6f3f4fcd5e3d6e5699ce422"
+dependencies = [
+ "anyhow",
+ "base64 0.21.7",
+ "directories-next",
+ "log",
+ "postcard",
+ "rustix",
+ "serde",
+ "serde_derive",
+ "sha2 0.10.8",
+ "toml",
+ "windows-sys 0.52.0",
+ "zstd",
+]
+
+[[package]]
+name = "wasmtime-component-macro"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0c3f57c4bc96f9b4a6ff4d6cb6e837913eff32e98d09e2b6d79b5c4647b415b"
+dependencies = [
+ "anyhow",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.63",
+ "wasmtime-component-util",
+ "wasmtime-wit-bindgen",
+ "wit-parser",
+]
+
+[[package]]
+name = "wasmtime-component-util"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1da707969bc31a565da9b32d087eb2370c95c6f2087c5539a15f2e3b27e77203"
+
+[[package]]
+name = "wasmtime-cranelift"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62cb6135ec46994299be711b78b03acaa9480de3715f827d450f0c947a84977c"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cranelift-codegen",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "cranelift-wasm",
+ "gimli",
+ "log",
+ "object 0.36.4",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser",
+ "wasmtime-environ",
+ "wasmtime-versioned-export-macros",
+]
+
+[[package]]
+name = "wasmtime-environ"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bcaa3b42a0718e9123da7fb75e8e13fc95df7db2a7e32e2f2f4f0d3333b7d6f"
+dependencies = [
+ "anyhow",
+ "cranelift-bitset",
+ "cranelift-entity",
+ "gimli",
+ "indexmap 2.2.6",
+ "log",
+ "object 0.36.4",
+ "postcard",
+ "serde",
+ "serde_derive",
+ "target-lexicon",
+ "wasm-encoder",
+ "wasmparser",
+ "wasmprinter",
+ "wasmtime-types",
+]
+
+[[package]]
+name = "wasmtime-jit-icache-coherence"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cfee42dac5148fc2664ab1f5cb8d7fa77a28d1a2cf1d9483abc2c3d751a58b9"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "wasmtime-slab"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42eb8f6515708ec67974998c3e644101db4186308985f5ef7c2ef324ff33c948"
+
+[[package]]
+name = "wasmtime-types"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "046873fb8fb3e9652f3fd76fe99c8c8129007695c3d73b2e307fdae40f6e324c"
+dependencies = [
+ "anyhow",
+ "cranelift-entity",
+ "serde",
+ "serde_derive",
+ "smallvec",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmtime-versioned-export-macros"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99c02af2e9dbeb427304d1a08787d70ed0dbfec1af2236616f84c9f1f03e7969"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.63",
+]
+
+[[package]]
+name = "wasmtime-wit-bindgen"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75f528f8b8a2376a3dacaf497d960216dd466d324425361e1e00e26de0a7705c"
+dependencies = [
+ "anyhow",
+ "heck 0.4.1",
+ "indexmap 2.2.6",
+ "wit-parser",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -5834,6 +6595,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
@@ -6016,6 +6786,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "winnow"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68a9bda4691f099d435ad181000724da8e5899daa10713c2d432552b9ccd3a6f"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winreg"
 version = "0.50.0"
@@ -6032,6 +6811,24 @@ version = "0.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
 
+[[package]]
+name = "wit-parser"
+version = "0.212.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ceeb0424aa8679f3fcf2d6e3cfa381f3d6fa6179976a2c05a6249dd2bb426716"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.2.6",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -6170,3 +6967,31 @@ dependencies = [
  "quote",
  "syn 2.0.63",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcf2b778a664581e31e389454a7072dab1647606d44f7feea22cd5abb9c9f3f9"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54a3ab4db68cea366acc5c897c7b4d4d1b8994a9cd6e6f841f8964566a419059"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.13+zstd.1.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38ff0f21cfee8f97d94cef41359e0c89aa6113028ab0291aa8ca0038995a95aa"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/test/src/sdk-harness/Cargo.toml b/test/src/sdk-harness/Cargo.toml
index 87716e1238c..3d28c7b1506 100644
--- a/test/src/sdk-harness/Cargo.toml
+++ b/test/src/sdk-harness/Cargo.toml
@@ -7,26 +7,27 @@ version = "0.0.0"
 publish = false
 
 [dependencies]
-assert_matches = "1.5.0"
+assert_matches = "1.5"
 
 # Dependencies from the `fuel-core` repository:
-fuel-core = { version = "0.27.0", default-features = false }
-fuel-core-client = { version = "0.27.0", default-features = false }
+fuel-core = { version = "0.40", default-features = false }
+# Using full semver as the workspace Cargo.toml (see the comment there) 
+fuel-core-client = { version = "0.40.0", default-features = false }
 
 # Dependencies from the `fuel-vm` repository:
-fuel-vm = { version = "0.50.0", features = ["random"] }
+fuel-vm = { version = "0.58", features = ["random"] }
 
 # Dependencies from the `fuels-rs` repository:
-fuels = { version = "0.63.0", features = ["fuel-core-lib"] }
+fuels = { version = "0.66.9", features = ["fuel-core-lib"] }
 
-hex = "0.4.3"
-paste = "1.0.14"
-pretty_assertions = "1.4.0"
+hex = "0.4"
+paste = "1.0"
+pretty_assertions = "1.4"
 rand = "0.8"
 sha2 = "0.10"
-sha3 = "0.10.1"
+sha3 = "0.10"
 tai64 = { version = "4.0", features = ["serde"] }
-tokio = { version = "1.12", features = ["rt", "macros"] }
+tokio = { version = "1.12", features = ["macros", "rt"] }
 
 [[test]]
 harness = true
diff --git a/test/src/sdk-harness/Forc.lock b/test/src/sdk-harness/Forc.lock
index d489df76c13..b05cb399826 100644
--- a/test/src/sdk-harness/Forc.lock
+++ b/test/src/sdk-harness/Forc.lock
@@ -324,6 +324,11 @@ name = "storage_vec_to_vec"
 source = "member"
 dependencies = ["std"]
 
+[[package]]
+name = "string_slice_predicate"
+source = "member"
+dependencies = ["core"]
+
 [[package]]
 name = "superabi"
 source = "member"
@@ -399,11 +404,41 @@ name = "tx_fields"
 source = "member"
 dependencies = ["std"]
 
+[[package]]
+name = "tx_input_count_predicate"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "tx_output_change_contract"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "tx_output_contract_creation_predicate"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "tx_output_count_predicate"
+source = "member"
+dependencies = ["std"]
+
 [[package]]
 name = "tx_output_predicate"
 source = "member"
 dependencies = ["std"]
 
+[[package]]
+name = "tx_type_predicate"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "tx_witness_predicate"
+source = "member"
+dependencies = ["std"]
+
 [[package]]
 name = "type_aliases"
 source = "member"
diff --git a/test/src/sdk-harness/Forc.toml b/test/src/sdk-harness/Forc.toml
index 725aa1effa7..97a7001d7da 100644
--- a/test/src/sdk-harness/Forc.toml
+++ b/test/src/sdk-harness/Forc.toml
@@ -46,6 +46,7 @@ members = [
   "test_projects/tx_fields",
   "test_projects/type_aliases",
   "test_projects/vec_in_abi",
+  "test_projects/string_slice/string_slice_predicate",
   "test_artifacts/auth_caller_contract",
   "test_artifacts/auth_caller_script",
   "test_artifacts/auth_predicate",
@@ -74,5 +75,11 @@ members = [
   "test_artifacts/storage_vec/svec_u16",
   "test_artifacts/storage_vec/svec_u64",
   "test_artifacts/tx_contract",
+  "test_artifacts/tx_input_count_predicate",
+  "test_artifacts/tx_output_change_contract",
+  "test_artifacts/tx_output_contract_creation_predicate",
+  "test_artifacts/tx_output_count_predicate",
   "test_artifacts/tx_output_predicate",
+  "test_artifacts/tx_type_predicate",
+  "test_artifacts/tx_witness_predicate",
 ]
diff --git a/test/src/sdk-harness/test_artifacts/auth_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/auth_predicate/src/main.sw
index 6541dc66529..16268669f3e 100644
--- a/test/src/sdk-harness/test_artifacts/auth_predicate/src/main.sw
+++ b/test/src/sdk-harness/test_artifacts/auth_predicate/src/main.sw
@@ -3,5 +3,9 @@ predicate;
 use std::auth::predicate_address;
 
 fn main(address: Address) -> bool {
-    address == predicate_address()
+    let result = match predicate_address() {
+        Some(address) => address,
+        None => return false,
+    };
+    address == result
 }
diff --git a/test/src/sdk-harness/test_artifacts/auth_testing_abi/src/main.sw b/test/src/sdk-harness/test_artifacts/auth_testing_abi/src/main.sw
index e45ec9c5f97..ab48c3e4756 100644
--- a/test/src/sdk-harness/test_artifacts/auth_testing_abi/src/main.sw
+++ b/test/src/sdk-harness/test_artifacts/auth_testing_abi/src/main.sw
@@ -4,4 +4,5 @@ abi AuthTesting {
     fn is_caller_external() -> bool;
     fn returns_msg_sender(expected_id: ContractId) -> bool;
     fn returns_msg_sender_address(expected_id: Address) -> bool;
+    fn returns_caller_addresses() -> Vec<Address>;
 }
diff --git a/test/src/sdk-harness/test_artifacts/auth_testing_contract/src/main.sw b/test/src/sdk-harness/test_artifacts/auth_testing_contract/src/main.sw
index c49a0540b15..ff145ae4d3d 100644
--- a/test/src/sdk-harness/test_artifacts/auth_testing_contract/src/main.sw
+++ b/test/src/sdk-harness/test_artifacts/auth_testing_contract/src/main.sw
@@ -26,7 +26,7 @@ impl AuthTesting for Contract {
         ret
     }
 
-    fn returns_msg_sender_address(_expected_id: Address) -> bool {
+    fn returns_msg_sender_address(expected_id: Address) -> bool {
         let result: Result<Identity, AuthError> = msg_sender();
         let mut ret = false;
         if result.is_err() {
@@ -34,8 +34,8 @@ impl AuthTesting for Contract {
         }
         let unwrapped = result.unwrap();
         match unwrapped {
-            Identity::Address(_) => {
-                ret = true
+            Identity::Address(address) => {
+                ret = expected_id == address
             },
             _ => {
                 ret = false
@@ -43,4 +43,8 @@ impl AuthTesting for Contract {
         }
         ret
     }
+
+    fn returns_caller_addresses() -> Vec<Address> {
+        caller_addresses()
+    }
 }
diff --git a/test/src/sdk-harness/test_artifacts/tx_contract/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_contract/src/main.sw
index 5755298265c..ed80700620c 100644
--- a/test/src/sdk-harness/test_artifacts/tx_contract/src/main.sw
+++ b/test/src/sdk-harness/test_artifacts/tx_contract/src/main.sw
@@ -8,7 +8,6 @@ use std::{
         Output,
         output_amount,
         output_count,
-        output_pointer,
         output_type,
     },
     tx::*,
@@ -16,154 +15,141 @@ use std::{
 
 abi TxContractTest {
     fn get_tx_type() -> Transaction;
-    fn get_tx_tip() -> u64;
+    fn get_tx_tip() -> Option<u64>;
     fn get_script_gas_limit() -> u64;
-    fn get_tx_maturity() -> u64;
-    fn get_tx_witness_limit() -> u64;
-    fn get_tx_max_fee() -> u64;
-    fn get_tx_script_length() -> u64;
-    fn get_tx_script_data_length() -> u64;
+    fn get_tx_maturity() -> Option<u32>;
+    fn get_tx_witness_limit() -> Option<u64>;
+    fn get_tx_max_fee() -> Option<u64>;
+    fn get_tx_script_length() -> Option<u64>;
+    fn get_tx_script_data_length() -> Option<u64>;
     fn get_tx_inputs_count() -> u64;
-    fn get_tx_outputs_count() -> u64;
+    fn get_tx_outputs_count() -> u16;
     fn get_tx_witnesses_count() -> u64;
-    fn get_tx_witness_pointer(index: u64) -> u64;
-    fn get_tx_witness_data_length(index: u64) -> u64;
-    fn get_tx_witness_data(index: u64) -> B512;
-    fn get_tx_script_start_pointer() -> u64;
-    fn get_tx_script_data_start_pointer() -> u64;
+    fn get_tx_witness_data_length(index: u64) -> Option<u64>;
+    fn get_tx_witness_data(index: u64) -> Option<B512>;
     fn get_tx_id() -> b256;
-    fn get_tx_script_bytecode_hash() -> b256;
+    fn get_tx_script_bytecode_hash() -> Option<b256>;
 
-    fn get_input_type(index: u64) -> Input;
-    fn get_tx_input_pointer(index: u64) -> u64;
-    fn get_input_coin_owner(index: u64) -> Address;
-    fn get_input_amount(index: u64) -> u64;
-    fn get_tx_input_predicate_data_pointer(index: u64) -> u64;
-    fn get_input_message_sender(index: u64) -> Address;
-    fn get_input_message_recipient(index: u64) -> Address;
-    fn get_input_message_nonce(index: u64) -> b256;
-    fn get_input_witness_index(index: u64) -> u16;
-    fn get_input_message_data_length(index: u64) -> u64;
-    fn get_input_predicate_length(index: u64) -> u64;
-    fn get_input_predicate_data_length(index: u64) -> u64;
-    fn get_input_message_data(index: u64, offset: u64, expected: [u8; 3]) -> bool;
+    fn get_input_type(index: u64) -> Option<Input>;
+    fn get_input_coin_owner(index: u64) -> Option<Address>;
+    fn get_input_amount(index: u64) -> Option<u64>;
+    fn get_input_message_sender(index: u64) -> Option<Address>;
+    fn get_input_message_recipient(index: u64) -> Option<Address>;
+    fn get_input_message_nonce(index: u64) -> Option<b256>;
+    fn get_input_witness_index(index: u64) -> Option<u16>;
+    fn get_input_message_data_length(index: u64) -> Option<u64>;
+    fn get_input_predicate_length(index: u64) -> Option<u64>;
+    fn get_input_predicate_data_length(index: u64) -> Option<u64>;
+    fn get_input_message_data(index: u64, offset: u64, expected_data_bytes: Bytes) -> bool;
     fn get_input_predicate(index: u64, bytecode: Vec<u8>) -> bool;
 
-    fn get_tx_output_pointer(index: u64) -> u64;
-    fn get_output_type(ptr: u64) -> Output;
-    fn get_tx_output_amount(index: u64) -> u64;
+    fn get_output_type(ptr: u64) -> Option<Output>;
+    fn get_tx_output_amount(index: u64) -> Option<u64>;
 }
 
 impl TxContractTest for Contract {
     fn get_tx_type() -> Transaction {
         tx_type()
     }
-    fn get_tx_tip() -> u64 {
-        tx_tip().unwrap()
+    fn get_tx_tip() -> Option<u64> {
+        tx_tip()
     }
     fn get_script_gas_limit() -> u64 {
         script_gas_limit()
     }
-    fn get_tx_maturity() -> u64 {
-        tx_maturity().unwrap()
+    fn get_tx_maturity() -> Option<u32> {
+        tx_maturity()
     }
-    fn get_tx_witness_limit() -> u64 {
-        tx_witness_limit().unwrap()
+    fn get_tx_witness_limit() -> Option<u64> {
+        tx_witness_limit()
     }
-    fn get_tx_max_fee() -> u64 {
-        tx_max_fee().unwrap()
+    fn get_tx_max_fee() -> Option<u64> {
+        tx_max_fee()
     }
-    fn get_tx_script_length() -> u64 {
+    fn get_tx_script_length() -> Option<u64> {
         tx_script_length()
     }
-    fn get_tx_script_data_length() -> u64 {
+    fn get_tx_script_data_length() -> Option<u64> {
         tx_script_data_length()
     }
     fn get_tx_inputs_count() -> u64 {
         input_count().as_u64()
     }
-    fn get_tx_outputs_count() -> u64 {
+    fn get_tx_outputs_count() -> u16 {
         output_count()
     }
     fn get_tx_witnesses_count() -> u64 {
         tx_witnesses_count()
     }
-    fn get_tx_witness_pointer(index: u64) -> u64 {
-        tx_witness_pointer(index)
-    }
-    fn get_tx_witness_data_length(index: u64) -> u64 {
+    fn get_tx_witness_data_length(index: u64) -> Option<u64> {
         tx_witness_data_length(index)
     }
-    fn get_tx_witness_data(index: u64) -> B512 {
+    fn get_tx_witness_data(index: u64) -> Option<B512> {
         tx_witness_data(index)
     }
-    fn get_tx_script_start_pointer() -> u64 {
-        asm(ptr: tx_script_start_pointer()) {
-            ptr: u64
-        }
-    }
-    fn get_tx_script_data_start_pointer() -> u64 {
-        asm(r1: tx_script_data_start_pointer()) {
-            r1: u64
-        }
-    }
     fn get_tx_id() -> b256 {
         tx_id()
     }
-    fn get_tx_script_bytecode_hash() -> b256 {
+    fn get_tx_script_bytecode_hash() -> Option<b256> {
         tx_script_bytecode_hash()
     }
-    fn get_tx_input_pointer(index: u64) -> u64 {
-        input_pointer(index)
-    }
-    fn get_input_type(index: u64) -> Input {
+    fn get_input_type(index: u64) -> Option<Input> {
         input_type(index)
     }
-    fn get_input_coin_owner(index: u64) -> Address {
-        input_coin_owner(index).unwrap()
+    fn get_input_coin_owner(index: u64) -> Option<Address> {
+        input_coin_owner(index)
     }
-    fn get_input_amount(index: u64) -> u64 {
-        input_amount(index).unwrap()
+    fn get_input_amount(index: u64) -> Option<u64> {
+        input_amount(index)
     }
-    fn get_tx_input_predicate_data_pointer(index: u64) -> u64 {
-        asm(r1: input_predicate_data_pointer(index).unwrap()) {
-            r1: u64
-        }
-    }
-    fn get_input_message_sender(index: u64) -> Address {
+    fn get_input_message_sender(index: u64) -> Option<Address> {
         input_message_sender(index)
     }
-    fn get_input_message_recipient(index: u64) -> Address {
+    fn get_input_message_recipient(index: u64) -> Option<Address> {
         input_message_recipient(index)
     }
-    fn get_input_message_nonce(index: u64) -> b256 {
+    fn get_input_message_nonce(index: u64) -> Option<b256> {
         input_message_nonce(index)
     }
-    fn get_input_witness_index(index: u64) -> u16 {
-        input_witness_index(index).unwrap()
+    fn get_input_witness_index(index: u64) -> Option<u16> {
+        input_witness_index(index)
     }
-    fn get_input_message_data_length(index: u64) -> u64 {
+    fn get_input_message_data_length(index: u64) -> Option<u64> {
         input_message_data_length(index)
     }
-    fn get_input_predicate_length(index: u64) -> u64 {
-        input_predicate_length(index).unwrap()
+    fn get_input_predicate_length(index: u64) -> Option<u64> {
+        input_predicate_length(index)
     }
-    fn get_input_predicate_data_length(index: u64) -> u64 {
-        input_predicate_data_length(index).unwrap()
+    fn get_input_predicate_data_length(index: u64) -> Option<u64> {
+        input_predicate_data_length(index)
     }
-    fn get_input_message_data(index: u64, offset: u64, expected: [u8; 3]) -> bool {
-        let data = input_message_data(index, offset);
+    fn get_input_message_data(index: u64, offset: u64, expected_data_bytes: Bytes) -> bool {
+        let data = match input_message_data(index, offset) {
+            Some(b) => b,
+            None => return false,
+        };
+
+        if expected_data_bytes.len() != data.len() {
+            return false
+        }
 
-        let mut expected_data_bytes = Bytes::new();
+        let mut iter = 0;
+        while iter < expected_data_bytes.len() {
+            if data.get(iter).unwrap() != expected_data_bytes.get(iter).unwrap() {
+                return false
+            }
+            iter += 1;
+        }
 
-        expected_data_bytes.push(expected[0]);
-        expected_data_bytes.push(expected[1]);
-        expected_data_bytes.push(expected[2]);
-        (data.get(0).unwrap() == expected_data_bytes.get(0).unwrap()) && (data.get(1).unwrap() == expected_data_bytes.get(1).unwrap()) && (data.get(2).unwrap() == expected_data_bytes.get(2).unwrap())
+        return true
     }
 
     fn get_input_predicate(index: u64, bytecode: Vec<u8>) -> bool {
-        let code = input_predicate(index);
+        let code = match input_predicate(index) {
+            Some(code) => code,
+            None => return false,
+        };
+
         assert(input_predicate_length(index).unwrap() == bytecode.len());
         let mut i = 0;
         while i < bytecode.len() {
@@ -172,13 +158,10 @@ impl TxContractTest for Contract {
         }
         true
     }
-    fn get_tx_output_pointer(index: u64) -> u64 {
-        output_pointer(index)
-    }
-    fn get_output_type(ptr: u64) -> Output {
+    fn get_output_type(ptr: u64) -> Option<Output> {
         output_type(ptr)
     }
-    fn get_tx_output_amount(index: u64) -> u64 {
+    fn get_tx_output_amount(index: u64) -> Option<u64> {
         output_amount(index)
     }
 }
diff --git a/test/src/sdk-harness/test_artifacts/tx_input_count_predicate/Forc.toml b/test/src/sdk-harness/test_artifacts/tx_input_count_predicate/Forc.toml
new file mode 100644
index 00000000000..2081295b12e
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_input_count_predicate/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_input_count_predicate"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/sdk-harness/test_artifacts/tx_input_count_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_input_count_predicate/src/main.sw
new file mode 100644
index 00000000000..18ece1aba67
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_input_count_predicate/src/main.sw
@@ -0,0 +1,7 @@
+predicate;
+
+use std::inputs::input_count;
+
+fn main(expected_count: u16) -> bool {
+    input_count() == expected_count
+}
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_change_contract/Forc.toml b/test/src/sdk-harness/test_artifacts/tx_output_change_contract/Forc.toml
new file mode 100644
index 00000000000..5a053f78b77
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_change_contract/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_output_change_contract"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_change_contract/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_output_change_contract/src/main.sw
new file mode 100644
index 00000000000..32aeeb5e7c9
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_change_contract/src/main.sw
@@ -0,0 +1,13 @@
+contract;
+
+use std::asset::transfer;
+
+abi TxOutputChangeContract {
+    fn send_assets(to: Address, asset: AssetId, amount: u64);
+}
+
+impl TxOutputChangeContract for Contract {
+    fn send_assets(to: Address, asset: AssetId, amount: u64) {
+        transfer(Identity::Address(to), asset, amount);
+    }
+}
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/Forc.lock b/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/Forc.lock
new file mode 100644
index 00000000000..b07177b8bba
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/Forc.lock
@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-1EABD6DBC885D01E"
+
+[[package]]
+name = "std"
+source = "path+from-root-1EABD6DBC885D01E"
+dependencies = ["core"]
+
+[[package]]
+name = "tx_output_contract_creation_predicate"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/Forc.toml b/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/Forc.toml
new file mode 100644
index 00000000000..66c581065d8
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_output_contract_creation_predicate"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/src/main.sw
new file mode 100644
index 00000000000..0b29417efb0
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_contract_creation_predicate/src/main.sw
@@ -0,0 +1,7 @@
+predicate;
+
+use std::outputs::{Output, output_type};
+
+fn main() -> bool {
+    output_type(2).unwrap() == Output::ContractCreated
+}
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_count_predicate/Forc.toml b/test/src/sdk-harness/test_artifacts/tx_output_count_predicate/Forc.toml
new file mode 100644
index 00000000000..16b4e270afd
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_count_predicate/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_output_count_predicate"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_count_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_output_count_predicate/src/main.sw
new file mode 100644
index 00000000000..26264019a30
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_output_count_predicate/src/main.sw
@@ -0,0 +1,7 @@
+predicate;
+
+use std::outputs::output_count;
+
+fn main(expected_count: u16) -> bool {
+    output_count() == expected_count
+}
diff --git a/test/src/sdk-harness/test_artifacts/tx_output_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_output_predicate/src/main.sw
index c7ca99d0d19..e639bd11833 100644
--- a/test/src/sdk-harness/test_artifacts/tx_output_predicate/src/main.sw
+++ b/test/src/sdk-harness/test_artifacts/tx_output_predicate/src/main.sw
@@ -1,13 +1,15 @@
 predicate;
 
-use std::outputs::{output_asset_id, output_asset_to};
+use std::outputs::{output_asset_id, output_asset_to, output_type, Output};
 
-fn main(index: u64, asset_id: b256, to: b256) -> bool {
+fn main(index: u64, asset_id: b256, to: b256, expected_type: Output) -> bool {
     let tx_asset_id = output_asset_id(index);
     let tx_to = output_asset_to(index);
+    let tx_output_type = output_type(index);
 
     assert(tx_asset_id.is_some() && tx_asset_id.unwrap().bits() == asset_id);
     assert(tx_to.is_some() && tx_to.unwrap().bits() == to);
+    assert(tx_output_type.is_some() && tx_output_type.unwrap() == expected_type);
 
     true
 }
diff --git a/test/src/sdk-harness/test_artifacts/tx_type_predicate/Forc.toml b/test/src/sdk-harness/test_artifacts/tx_type_predicate/Forc.toml
new file mode 100644
index 00000000000..23ca628cedf
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_type_predicate/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_type_predicate"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/sdk-harness/test_artifacts/tx_type_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_type_predicate/src/main.sw
new file mode 100644
index 00000000000..59bd4f10714
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_type_predicate/src/main.sw
@@ -0,0 +1,7 @@
+predicate;
+
+use std::tx::{tx_type, Transaction};
+
+fn main(expected_type: Transaction) -> bool {
+    tx_type() == expected_type
+}
diff --git a/test/src/sdk-harness/test_artifacts/tx_witness_predicate/Forc.toml b/test/src/sdk-harness/test_artifacts/tx_witness_predicate/Forc.toml
new file mode 100644
index 00000000000..d7aa6cdc427
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_witness_predicate/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "tx_witness_predicate"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }
diff --git a/test/src/sdk-harness/test_artifacts/tx_witness_predicate/src/main.sw b/test/src/sdk-harness/test_artifacts/tx_witness_predicate/src/main.sw
new file mode 100644
index 00000000000..adb0ea9dbc9
--- /dev/null
+++ b/test/src/sdk-harness/test_artifacts/tx_witness_predicate/src/main.sw
@@ -0,0 +1,22 @@
+predicate;
+
+use std::tx::{tx_witnesses_count, tx_witness_data_length, tx_witness_data};
+
+fn main(index: u64, expected_count: u64, expected_length: u64, expected_data: [u8; 64]) -> bool {
+    let count: u64 = tx_witnesses_count();
+    let length: Option<u64> = tx_witness_data_length(index);
+    let data: Option<[u8; 64]> = tx_witness_data(index);
+
+    assert(count == expected_count);
+    assert(length.is_some() && length.unwrap() == expected_length);
+
+    assert(data.is_some());
+    let data = data.unwrap();    
+    let mut iter = 0;
+    while iter < 64 {
+        assert(data[iter] == expected_data[iter]);
+        iter += 1;
+    }
+
+    true
+}
diff --git a/test/src/sdk-harness/test_projects/asset_ops/mod.rs b/test/src/sdk-harness/test_projects/asset_ops/mod.rs
index 5706f4ab587..a04e312120a 100644
--- a/test/src/sdk-harness/test_projects/asset_ops/mod.rs
+++ b/test/src/sdk-harness/test_projects/asset_ops/mod.rs
@@ -250,14 +250,14 @@ async fn can_mint_and_send_to_address() {
     fuelcontract_instance
         .methods()
         .mint_and_send_to_address(amount, recipient, Bits256(*sub_id))
-        .append_variable_outputs(1)
+        .with_variable_output_policy(VariableOutputPolicy::Exactly(1))
         .call()
         .await
         .unwrap();
 
     assert_eq!(
         wallet
-            .get_spendable_resources(AssetId::from(asset_id_array), 1)
+            .get_spendable_resources(AssetId::from(asset_id_array), 1, None)
             .await
             .unwrap()[0]
             .amount(),
@@ -278,14 +278,14 @@ async fn can_perform_generic_mint_to_with_address() {
     fuelcontract_instance
         .methods()
         .generic_mint_to(amount, Identity::Address(address.into()), Bits256(*sub_id))
-        .append_variable_outputs(1)
+        .with_variable_output_policy(VariableOutputPolicy::Exactly(1))
         .call()
         .await
         .unwrap();
 
     assert_eq!(
         wallet
-            .get_spendable_resources(AssetId::from(asset_id_array), 1)
+            .get_spendable_resources(AssetId::from(asset_id_array), 1, None)
             .await
             .unwrap()[0]
             .amount(),
@@ -357,14 +357,14 @@ async fn can_perform_generic_transfer_to_address() {
             Bits256(*asset_id),
             Identity::Address(address.into()),
         )
-        .append_variable_outputs(1)
+        .with_variable_output_policy(VariableOutputPolicy::Exactly(1))
         .call()
         .await
         .unwrap();
 
     assert_eq!(
         wallet
-            .get_spendable_resources(AssetId::from(asset_id_array), 1)
+            .get_spendable_resources(AssetId::from(asset_id_array), 1, None)
             .await
             .unwrap()[0]
             .amount(),
diff --git a/test/src/sdk-harness/test_projects/auth/mod.rs b/test/src/sdk-harness/test_projects/auth/mod.rs
index fa6e94b378f..2fefd28f8c8 100644
--- a/test/src/sdk-harness/test_projects/auth/mod.rs
+++ b/test/src/sdk-harness/test_projects/auth/mod.rs
@@ -4,7 +4,14 @@ use fuels::{
         wallet::{Wallet, WalletUnlocked},
     },
     prelude::*,
-    types::ContractId,
+    tx::UtxoId,
+    types::{
+        coin::{Coin, CoinStatus},
+        coin_type::CoinType,
+        input::Input,
+        message::{Message, MessageStatus},
+        Bytes32, ContractId,
+    },
 };
 use std::str::FromStr;
 
@@ -64,6 +71,498 @@ async fn msg_sender_from_contract() {
     assert!(result.value);
 }
 
+#[tokio::test]
+async fn input_message_msg_sender_from_contract() {
+    // Wallet
+    let mut wallet = WalletUnlocked::new_random(None);
+
+    // Setup coins and messages
+    let coins = setup_single_asset_coins(wallet.address(), AssetId::BASE, 100, 1000);
+    let msg = setup_single_message(
+        &Bech32Address {
+            hrp: "".to_string(),
+            hash: Default::default(),
+        },
+        wallet.address(),
+        DEFAULT_COIN_AMOUNT,
+        10.into(),
+        vec![],
+    );
+
+    let provider = setup_test_provider(coins.clone(), vec![msg.clone()], None, None)
+        .await
+        .unwrap();
+    wallet.set_provider(provider.clone());
+
+    // Setup contract
+    let id = Contract::load_from(
+        "test_artifacts/auth_testing_contract/out/release/auth_testing_contract.bin",
+        LoadConfiguration::default(),
+    )
+    .unwrap()
+    .deploy(&wallet, TxPolicies::default())
+    .await
+    .unwrap();
+    let instance = AuthContract::new(id.clone(), wallet.clone());
+
+    // Start building transactions
+    let call_handler = instance
+        .methods()
+        .returns_msg_sender_address(Address::from(*msg.recipient.hash()));
+    let mut tb = call_handler.transaction_builder().await.unwrap();
+
+    // Inputs
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Message(
+            wallet
+                .get_messages()
+                .await
+                .unwrap()
+                .first()
+                .unwrap()
+                .clone(),
+        ),
+    });
+
+    // Build transaction
+    tb.add_signer(wallet.clone()).unwrap();
+    let tx = tb.build(provider.clone()).await.unwrap();
+
+    // Send and verify
+    let tx_id = provider.send_transaction(tx).await.unwrap();
+    let tx_status = provider.tx_status(&tx_id).await.unwrap();
+    let response = call_handler.get_response_from(tx_status).unwrap();
+    assert!(response.value);
+}
+
+#[tokio::test]
+async fn caller_addresses_from_messages() {
+    let mut wallet1 = WalletUnlocked::new_random(None);
+    let mut wallet2 = WalletUnlocked::new_random(None);
+    let mut wallet3 = WalletUnlocked::new_random(None);
+    let mut wallet4 = WalletUnlocked::new_random(None);
+
+    // Setup message
+    let message_amount = 10;
+    let message1 = Message {
+        sender: wallet1.address().clone(),
+        recipient: wallet1.address().clone(),
+        nonce: 0.into(),
+        amount: message_amount,
+        data: vec![],
+        da_height: 0,
+        status: MessageStatus::Unspent,
+    };
+    let message2 = Message {
+        sender: wallet2.address().clone(),
+        recipient: wallet2.address().clone(),
+        nonce: 1.into(),
+        amount: message_amount,
+        data: vec![],
+        da_height: 0,
+        status: MessageStatus::Unspent,
+    };
+    let message3 = Message {
+        sender: wallet3.address().clone(),
+        recipient: wallet3.address().clone(),
+        nonce: 2.into(),
+        amount: message_amount,
+        data: vec![],
+        da_height: 0,
+        status: MessageStatus::Unspent,
+    };
+    let mut message_vec: Vec<Message> = Vec::new();
+    message_vec.push(message1);
+    message_vec.push(message2);
+    message_vec.push(message3);
+
+    // Setup Coin
+    let coin_amount = 10;
+    let coin = Coin {
+        owner: wallet4.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 0),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let provider = setup_test_provider(vec![coin], message_vec, Some(node_config), None)
+        .await
+        .unwrap();
+
+    wallet1.set_provider(provider.clone());
+    wallet2.set_provider(provider.clone());
+    wallet3.set_provider(provider.clone());
+
+    wallet4.set_provider(provider.clone());
+
+    let id_1 = Contract::load_from(
+        "test_artifacts/auth_testing_contract/out/release/auth_testing_contract.bin",
+        LoadConfiguration::default(),
+    )
+    .unwrap()
+    .deploy(&wallet4, TxPolicies::default())
+    .await
+    .unwrap();
+    
+    let auth_instance = AuthContract::new(id_1.clone(), wallet4.clone());
+    
+    let result = auth_instance
+        .methods()
+        .returns_caller_addresses()
+        .call()
+        .await
+        .unwrap();
+    
+    assert_eq!(result.value, vec![Address::from(*wallet4.address().hash())]);
+
+    // Start building transactions
+    let call_handler = auth_instance
+        .methods()
+        .returns_caller_addresses();
+    let mut tb = call_handler.transaction_builder().await.unwrap();
+
+    // Inputs
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Message(
+            setup_single_message(
+                &wallet1.address().clone(),
+                &wallet1.address().clone(),
+                message_amount,
+                0.into(),
+                vec![],
+            )
+        ),
+    });
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Message(
+            setup_single_message(
+                &wallet2.address().clone(),
+                &wallet2.address().clone(),
+                message_amount,
+                1.into(),
+                vec![],
+            )
+        ),
+    });
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Message(
+            setup_single_message(
+                &wallet3.address().clone(),
+                &wallet3.address().clone(),
+                message_amount,
+                2.into(),
+                vec![],
+            )
+        ),
+    });
+
+    // Build transaction
+    tb.add_signer(wallet1.clone()).unwrap();
+    tb.add_signer(wallet2.clone()).unwrap();
+    tb.add_signer(wallet3.clone()).unwrap();
+    
+    let provider = wallet1.provider().unwrap();
+    let tx = tb.build(provider.clone()).await.unwrap();
+
+    // Send and verify
+    let tx_id = provider.send_transaction(tx).await.unwrap();
+    let tx_status = provider.tx_status(&tx_id).await.unwrap();
+    let result = call_handler.get_response_from(tx_status).unwrap();
+
+    assert!(result.value.contains(&Address::from(wallet1.address().clone())));
+    assert!(result.value.contains(&Address::from(wallet2.address().clone())));
+    assert!(result.value.contains(&Address::from(wallet3.address().clone())));
+}
+
+#[tokio::test]
+async fn caller_addresses_from_coins() {
+    let mut wallet1 = WalletUnlocked::new_random(None);
+    let mut wallet2 = WalletUnlocked::new_random(None);
+    let mut wallet3 = WalletUnlocked::new_random(None);
+    let mut wallet4 = WalletUnlocked::new_random(None);
+
+    // Setup Coin
+    let coin_amount = 10;
+    let coin1 = Coin {
+        owner: wallet1.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 0),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+    let coin2 = Coin {
+        owner: wallet2.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 1),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+    let coin3 = Coin {
+        owner: wallet3.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 2),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+    let coin4 = Coin {
+        owner: wallet4.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 3),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+
+    let mut coin_vec: Vec<Coin> = Vec::new();
+    coin_vec.push(coin1);
+    coin_vec.push(coin2);
+    coin_vec.push(coin3);
+    coin_vec.push(coin4);
+
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let provider = setup_test_provider(coin_vec, vec![], Some(node_config), None)
+        .await
+        .unwrap();
+
+    wallet1.set_provider(provider.clone());
+    wallet2.set_provider(provider.clone());
+    wallet3.set_provider(provider.clone());
+
+    wallet4.set_provider(provider.clone());
+
+    let id_1 = Contract::load_from(
+        "test_artifacts/auth_testing_contract/out/release/auth_testing_contract.bin",
+        LoadConfiguration::default(),
+    )
+    .unwrap()
+    .deploy(&wallet4, TxPolicies::default())
+    .await
+    .unwrap();
+    
+    let auth_instance = AuthContract::new(id_1.clone(), wallet4.clone());
+    
+    let result = auth_instance
+        .methods()
+        .returns_caller_addresses()
+        .call()
+        .await
+        .unwrap();
+    
+    assert_eq!(result.value, vec![Address::from(*wallet4.address().hash())]);
+
+    // Start building transactions
+    let call_handler = auth_instance
+        .methods()
+        .returns_caller_addresses();
+    let mut tb = call_handler.transaction_builder().await.unwrap();
+
+    // Inputs
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Coin(
+            Coin {
+                owner: wallet1.address().clone(),
+                utxo_id: UtxoId::new(Bytes32::zeroed(), 0),
+                amount: coin_amount,
+                asset_id: AssetId::default(),
+                status: CoinStatus::Unspent,
+                block_created: Default::default(),
+            }
+        ),
+    });
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Coin(
+            Coin {
+                owner: wallet2.address().clone(),
+                utxo_id: UtxoId::new(Bytes32::zeroed(), 1),
+                amount: coin_amount,
+                asset_id: AssetId::default(),
+                status: CoinStatus::Unspent,
+                block_created: Default::default(),
+            }
+        ),
+    });
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Coin(
+            Coin {
+                owner: wallet3.address().clone(),
+                utxo_id: UtxoId::new(Bytes32::zeroed(), 2),
+                amount: coin_amount,
+                asset_id: AssetId::default(),
+                status: CoinStatus::Unspent,
+                block_created: Default::default(),
+            }
+        ),
+    });
+
+    // Build transaction
+    tb.add_signer(wallet1.clone()).unwrap();
+    tb.add_signer(wallet2.clone()).unwrap();
+    tb.add_signer(wallet3.clone()).unwrap();
+    
+    let provider = wallet1.provider().unwrap();
+    let tx = tb.build(provider.clone()).await.unwrap();
+
+    // Send and verify
+    let tx_id = provider.send_transaction(tx).await.unwrap();
+    let tx_status = provider.tx_status(&tx_id).await.unwrap();
+    let result = call_handler.get_response_from(tx_status).unwrap();
+
+    assert!(result.value.contains(&Address::from(wallet1.address().clone())));
+    assert!(result.value.contains(&Address::from(wallet2.address().clone())));
+    assert!(result.value.contains(&Address::from(wallet3.address().clone())));
+}
+
+#[tokio::test]
+async fn caller_addresses_from_coins_and_messages() {
+    let mut wallet1 = WalletUnlocked::new_random(None);
+    let mut wallet2 = WalletUnlocked::new_random(None);
+    let mut wallet3 = WalletUnlocked::new_random(None);
+    let mut wallet4 = WalletUnlocked::new_random(None);
+
+    let message_amount = 10;
+    let message1 = Message {
+        sender: wallet1.address().clone(),
+        recipient: wallet1.address().clone(),
+        nonce: 0.into(),
+        amount: message_amount,
+        data: vec![],
+        da_height: 0,
+        status: MessageStatus::Unspent,
+    };
+
+    // Setup Coin
+    let coin_amount = 10;
+    let coin2 = Coin {
+        owner: wallet2.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 1),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+    let coin3 = Coin {
+        owner: wallet3.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 2),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+    let coin4 = Coin {
+        owner: wallet4.address().clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 3),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+
+    let mut coin_vec: Vec<Coin> = Vec::new();
+    coin_vec.push(coin2);
+    coin_vec.push(coin3);
+    coin_vec.push(coin4);
+
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let provider = setup_test_provider(coin_vec, vec![message1], Some(node_config), None)
+        .await
+        .unwrap();
+
+    wallet1.set_provider(provider.clone());
+    wallet2.set_provider(provider.clone());
+    wallet3.set_provider(provider.clone());
+
+    wallet4.set_provider(provider.clone());
+
+    let id_1 = Contract::load_from(
+        "test_artifacts/auth_testing_contract/out/release/auth_testing_contract.bin",
+        LoadConfiguration::default(),
+    )
+    .unwrap()
+    .deploy(&wallet4, TxPolicies::default())
+    .await
+    .unwrap();
+    
+    let auth_instance = AuthContract::new(id_1.clone(), wallet4.clone());
+    
+    let result = auth_instance
+        .methods()
+        .returns_caller_addresses()
+        .call()
+        .await
+        .unwrap();
+    
+    assert_eq!(result.value, vec![Address::from(*wallet4.address().hash())]);
+
+    // Start building transactions
+    let call_handler = auth_instance
+        .methods()
+        .returns_caller_addresses();
+    let mut tb = call_handler.transaction_builder().await.unwrap();
+
+    // Inputs
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Message(
+            setup_single_message(
+                &wallet1.address().clone(),
+                &wallet1.address().clone(),
+                message_amount,
+                0.into(),
+                vec![],
+            )
+        ),
+    });
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Coin(
+            Coin {
+                owner: wallet2.address().clone(),
+                utxo_id: UtxoId::new(Bytes32::zeroed(), 1),
+                amount: coin_amount,
+                asset_id: AssetId::default(),
+                status: CoinStatus::Unspent,
+                block_created: Default::default(),
+            }
+        ),
+    });
+    tb.inputs_mut().push(Input::ResourceSigned {
+        resource: CoinType::Coin(
+            Coin {
+                owner: wallet3.address().clone(),
+                utxo_id: UtxoId::new(Bytes32::zeroed(), 2),
+                amount: coin_amount,
+                asset_id: AssetId::default(),
+                status: CoinStatus::Unspent,
+                block_created: Default::default(),
+            }
+        ),
+    });
+
+    // Build transaction
+    tb.add_signer(wallet1.clone()).unwrap();
+    tb.add_signer(wallet2.clone()).unwrap();
+    tb.add_signer(wallet3.clone()).unwrap();
+    
+    let provider = wallet1.provider().unwrap();
+    let tx = tb.build(provider.clone()).await.unwrap();
+
+    // Send and verify
+    let tx_id = provider.send_transaction(tx).await.unwrap();
+    let tx_status = provider.tx_status(&tx_id).await.unwrap();
+    let result = call_handler.get_response_from(tx_status).unwrap();
+
+    assert!(result.value.contains(&Address::from(wallet1.address().clone())));
+    assert!(result.value.contains(&Address::from(wallet2.address().clone())));
+    assert!(result.value.contains(&Address::from(wallet3.address().clone())));
+}
+
 async fn get_contracts() -> (
     AuthContract<WalletUnlocked>,
     ContractId,
@@ -115,15 +614,17 @@ async fn can_get_predicate_address() {
             coin_amount: 1_000,
         }],
     );
-    let wallets = &launch_custom_provider_and_get_wallets(wallets_config, None, None)
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let wallets = &launch_custom_provider_and_get_wallets(wallets_config, Some(node_config), None)
         .await
         .unwrap();
     let first_wallet = &wallets[0];
     let second_wallet = &wallets[1];
 
-    // Setup Predciate
+    // Setup predicate.
     let hex_predicate_address: &str =
-        "0xf868533e744aeda1df2fcd5589d822db7087e61702662356961029622b6b75f2";
+        "0x5dcc82a88eebb07fb628db93d11ec38f085cbf36453a7135fea41b93cc44e118";
     let predicate_address =
         Address::from_str(hex_predicate_address).expect("failed to create Address from string");
     let predicate_bech32_address = Bech32Address::from(predicate_address);
@@ -136,6 +637,10 @@ async fn can_get_predicate_address() {
             .with_provider(first_wallet.try_provider().unwrap().clone())
             .with_data(predicate_data);
 
+    // If this test fails, it can be the predicate address
+    // Uncomment the next line, get the predicate address and update above.
+    // dbg!(&predicate);
+
     // Next, we lock some assets in this predicate using the first wallet:
     // First wallet transfers amount to predicate.
     first_wallet
@@ -198,7 +703,7 @@ async fn when_incorrect_predicate_address_passed() {
     let first_wallet = &wallets[0];
     let second_wallet = &wallets[1];
 
-    // Setup Predciate with incorrect address
+    // Setup predicate with incorrect address.
     let hex_predicate_address: &str =
         "0x36bf4bd40f2a3b3db595ef8fd8b21dbe9e6c0dd7b419b4413ff6b584ce7da5d7";
     let predicate_address =
@@ -240,3 +745,91 @@ async fn when_incorrect_predicate_address_passed() {
         .await
         .unwrap();
 }
+
+#[tokio::test]
+async fn can_get_predicate_address_in_message() {
+    // Setup predicate address.
+    let hex_predicate_address: &str =
+        "0x5dcc82a88eebb07fb628db93d11ec38f085cbf36453a7135fea41b93cc44e118";
+    let predicate_address =
+        Address::from_str(hex_predicate_address).expect("failed to create Address from string");
+    let predicate_bech32_address = Bech32Address::from(predicate_address);
+
+    // Setup message
+    let message_amount = 1;
+    let message = Message {
+        sender: Bech32Address::default(),
+        recipient: predicate_bech32_address.clone(),
+        nonce: 0.into(),
+        amount: message_amount,
+        data: vec![],
+        da_height: 0,
+        status: MessageStatus::Unspent,
+    };
+    let mut message_vec: Vec<Message> = Vec::new();
+    message_vec.push(message);
+
+    // Setup Coin
+    let coin_amount = 0;
+    let coin = Coin {
+        owner: predicate_bech32_address.clone(),
+        utxo_id: UtxoId::new(Bytes32::zeroed(), 0),
+        amount: coin_amount,
+        asset_id: AssetId::default(),
+        status: CoinStatus::Unspent,
+        block_created: Default::default(),
+    };
+    let mut coin_vec: Vec<Coin> = Vec::new();
+    coin_vec.push(coin);
+
+    let mut wallet = WalletUnlocked::new_random(None);
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let provider = setup_test_provider(coin_vec, message_vec, Some(node_config), None)
+        .await
+        .unwrap();
+    wallet.set_provider(provider.clone());
+
+    // Setup predicate.
+    let predicate_data = AuthPredicateEncoder::default()
+        .encode_data(predicate_bech32_address)
+        .unwrap();
+    let predicate: Predicate =
+        Predicate::load_from("test_artifacts/auth_predicate/out/release/auth_predicate.bin")
+            .unwrap()
+            .with_provider(wallet.try_provider().unwrap().clone())
+            .with_data(predicate_data);
+
+    // If this test fails, it can be the predicate address
+    // Uncomment the next line, get the predicate address and update above.
+    // dbg!(&predicate);
+
+    // Check predicate balance.
+    let balance = predicate
+        .get_asset_balance(&AssetId::default())
+        .await
+        .unwrap();
+    assert_eq!(balance, message_amount);
+
+    // Spend the message
+    predicate
+        .transfer(
+            wallet.address(),
+            message_amount,
+            AssetId::default(),
+            TxPolicies::default(),
+        )
+        .await
+        .unwrap();
+
+    // The predicate has spent the funds
+    let predicate_balance = predicate
+        .get_asset_balance(&AssetId::default())
+        .await
+        .unwrap();
+    assert_eq!(predicate_balance, 0);
+
+    // Funds were transferred
+    let wallet_balance = wallet.get_asset_balance(&AssetId::default()).await.unwrap();
+    assert_eq!(wallet_balance, message_amount);
+}
diff --git a/test/src/sdk-harness/test_projects/call_frames/mod.rs b/test/src/sdk-harness/test_projects/call_frames/mod.rs
index bcfaa98f5b1..72af0ad5d51 100644
--- a/test/src/sdk-harness/test_projects/call_frames/mod.rs
+++ b/test/src/sdk-harness/test_projects/call_frames/mod.rs
@@ -1,4 +1,3 @@
-use fuel_vm::consts::VM_MAX_RAM;
 use fuels::{accounts::wallet::WalletUnlocked, prelude::*, types::ContractId};
 
 abigen!(Contract(
@@ -36,7 +35,10 @@ async fn can_get_id_contract_id_this() {
 async fn can_get_code_size() {
     let (instance, _id) = get_call_frames_instance().await;
     let result = instance.methods().get_code_size().call().await.unwrap();
-    assert!(is_within_range(result.value));
+    // Check if codesize is between 1000 and 7000. Arbitrary endpoints, current codesize is 7208
+    // but the lower bound future proofs against compiler optimizations
+    dbg!(result.value);
+    assert!(result.value > 1000 && result.value < 7300);
 }
 
 #[tokio::test]
@@ -110,7 +112,3 @@ async fn can_get_second_param_multiple_params2() {
         .unwrap();
     assert_eq!(result.value, (300, expected_struct, expected_struct2));
 }
-
-fn is_within_range(n: u64) -> bool {
-    n > 0 && n <= VM_MAX_RAM
-}
diff --git a/test/src/sdk-harness/test_projects/configurables_in_contract/mod.rs b/test/src/sdk-harness/test_projects/configurables_in_contract/mod.rs
index c75ad575422..b1e9044d227 100644
--- a/test/src/sdk-harness/test_projects/configurables_in_contract/mod.rs
+++ b/test/src/sdk-harness/test_projects/configurables_in_contract/mod.rs
@@ -75,7 +75,7 @@ async fn contract_configurables() -> Result<()> {
         .with_STRUCT(new_struct.clone())?
         .with_ENUM(new_enum.clone())?
         .with_ADDRESS(new_address.clone())?
-        .with_CONTRACT_ID(new_contract_id.clone())?;
+        .with_MY_CONTRACT_ID(new_contract_id.clone())?;
 
     let contract_id = Contract::load_from(
         "test_projects/configurables_in_contract/out/release/configurables_in_contract.bin",
diff --git a/test/src/sdk-harness/test_projects/configurables_in_contract/src/main.sw b/test/src/sdk-harness/test_projects/configurables_in_contract/src/main.sw
index d70190664e2..3c8e114fc34 100644
--- a/test/src/sdk-harness/test_projects/configurables_in_contract/src/main.sw
+++ b/test/src/sdk-harness/test_projects/configurables_in_contract/src/main.sw
@@ -21,7 +21,7 @@ configurable {
     },
     ENUM: EnumWithGeneric<bool> = EnumWithGeneric::VariantOne(true),
     ADDRESS: Address = Address::zero(),
-    CONTRACT_ID: ContractId = ContractId::zero(),
+    MY_CONTRACT_ID: ContractId = ContractId::zero(),
 }
 
 abi TestContract {
@@ -30,6 +30,6 @@ abi TestContract {
 
 impl TestContract for Contract {
     fn return_configurables() -> (u8, bool, [u32; 3], str[4], StructWithGeneric<u8>, EnumWithGeneric<bool>, Address, ContractId) {
-        (U8, BOOL, ARRAY, STR_4, STRUCT, ENUM, ADDRESS, CONTRACT_ID)
+        (U8, BOOL, ARRAY, STR_4, STRUCT, ENUM, ADDRESS, MY_CONTRACT_ID)
     }
 }
diff --git a/test/src/sdk-harness/test_projects/ec_recover_and_match_predicate/mod.rs b/test/src/sdk-harness/test_projects/ec_recover_and_match_predicate/mod.rs
index 4287f8db245..a9e61a540eb 100644
--- a/test/src/sdk-harness/test_projects/ec_recover_and_match_predicate/mod.rs
+++ b/test/src/sdk-harness/test_projects/ec_recover_and_match_predicate/mod.rs
@@ -43,7 +43,9 @@ async fn ec_recover_and_match_predicate_test() -> Result<()> {
         })
         .collect::<Vec<_>>();
 
-    let provider = setup_test_provider(all_coins, vec![], None, None)
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let provider = setup_test_provider(all_coins, vec![], Some(node_config), None)
         .await
         .unwrap();
 
diff --git a/test/src/sdk-harness/test_projects/exponentiation/mod.rs b/test/src/sdk-harness/test_projects/exponentiation/mod.rs
index f7a27908f80..d1d3ebdd76f 100644
--- a/test/src/sdk-harness/test_projects/exponentiation/mod.rs
+++ b/test/src/sdk-harness/test_projects/exponentiation/mod.rs
@@ -23,6 +23,8 @@ async fn overflowing_pow_u64_panics() {
 #[tokio::test]
 // TODO won't overflow until https://github.com/FuelLabs/fuel-specs/issues/90 lands
 // #[should_panic(expected = "ArithmeticOverflow")]
+// Temporary fix in: https://github.com/FuelLabs/sway/pull/6340
+#[should_panic]
 async fn overflowing_pow_u32_panics() {
     let wallet = launch_provider_and_get_wallet().await.unwrap();
     let (pow_instance, _) = get_pow_test_instance(wallet).await;
@@ -50,6 +52,8 @@ async fn overflowing_pow_u32_panics_max() {
 #[tokio::test]
 // TODO won't overflow until https://github.com/FuelLabs/fuel-specs/issues/90 lands
 // #[should_panic(expected = "ArithmeticOverflow")]
+// Temporary fix in: https://github.com/FuelLabs/sway/pull/6340
+#[should_panic]
 async fn overflowing_pow_u16_panics() {
     let wallet = launch_provider_and_get_wallet().await.unwrap();
     let (pow_instance, _) = get_pow_test_instance(wallet).await;
@@ -77,6 +81,8 @@ async fn overflowing_pow_u16_panics_max() {
 #[tokio::test]
 // TODO won't overflow until https://github.com/FuelLabs/fuel-specs/issues/90 lands
 // #[should_panic(expected = "ArithmeticOverflow")]
+// Temporary fix in: https://github.com/FuelLabs/sway/pull/6340
+#[should_panic]
 async fn overflowing_pow_u8_panics() {
     let wallet = launch_provider_and_get_wallet().await.unwrap();
     let (pow_instance, _) = get_pow_test_instance(wallet).await;
diff --git a/test/src/sdk-harness/test_projects/harness.rs b/test/src/sdk-harness/test_projects/harness.rs
index 5ba5b57654a..bc01e3cbc5b 100644
--- a/test/src/sdk-harness/test_projects/harness.rs
+++ b/test/src/sdk-harness/test_projects/harness.rs
@@ -43,6 +43,7 @@ mod storage_vec;
 mod storage_vec_nested;
 mod storage_vec_of_storage_string;
 mod storage_vec_to_vec;
+mod string_slice;
 mod superabi;
 mod superabi_supertrait;
 mod tx_fields;
diff --git a/test/src/sdk-harness/test_projects/predicate_data_simple/mod.rs b/test/src/sdk-harness/test_projects/predicate_data_simple/mod.rs
index c75d69a03d4..6d5b4e78fcb 100644
--- a/test/src/sdk-harness/test_projects/predicate_data_simple/mod.rs
+++ b/test/src/sdk-harness/test_projects/predicate_data_simple/mod.rs
@@ -15,7 +15,16 @@ async fn setup() -> (Vec<u8>, Address, WalletUnlocked, u64, AssetId) {
             .unwrap();
     let predicate_address = fuel_tx::Input::predicate_owner(&predicate_code);
 
-    let wallet = launch_provider_and_get_wallet().await.unwrap();
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let mut wallets = launch_custom_provider_and_get_wallets(
+        WalletsConfig::new(Some(1), None, None),
+        Some(node_config),
+        None,
+    )
+    .await
+    .unwrap();
+    let wallet = wallets.pop().unwrap();
     (
         predicate_code,
         predicate_address,
@@ -33,7 +42,11 @@ async fn create_predicate(
 ) {
     let provider = wallet.provider().unwrap();
     let wallet_coins = wallet
-        .get_asset_inputs_for_amount(asset_id, wallet.get_asset_balance(&asset_id).await.unwrap())
+        .get_asset_inputs_for_amount(
+            asset_id,
+            wallet.get_asset_balance(&asset_id).await.unwrap(),
+            None,
+        )
         .await
         .unwrap();
 
diff --git a/test/src/sdk-harness/test_projects/predicate_data_simple/src/main.sw b/test/src/sdk-harness/test_projects/predicate_data_simple/src/main.sw
index 873051e2cc8..c803a2d790c 100644
--- a/test/src/sdk-harness/test_projects/predicate_data_simple/src/main.sw
+++ b/test/src/sdk-harness/test_projects/predicate_data_simple/src/main.sw
@@ -3,7 +3,10 @@ predicate;
 use std::inputs::input_predicate_data;
 
 fn main() -> bool {
-    let received: u32 = input_predicate_data::<u32>(0);
+    let received: u32 = match input_predicate_data::<u32>(0) {
+        Some(data) => data,
+        None => return false,
+    };
     let expected: u32 = 12345;
 
     received == expected
diff --git a/test/src/sdk-harness/test_projects/predicate_data_struct/mod.rs b/test/src/sdk-harness/test_projects/predicate_data_struct/mod.rs
index 3e7d4090e3f..8836491428a 100644
--- a/test/src/sdk-harness/test_projects/predicate_data_struct/mod.rs
+++ b/test/src/sdk-harness/test_projects/predicate_data_struct/mod.rs
@@ -15,7 +15,16 @@ async fn setup() -> (Vec<u8>, Address, WalletUnlocked, u64, AssetId) {
             .unwrap();
     let predicate_address = fuel_tx::Input::predicate_owner(&predicate_code);
 
-    let wallet = launch_provider_and_get_wallet().await.unwrap();
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let mut wallets = launch_custom_provider_and_get_wallets(
+        WalletsConfig::new(Some(1), None, None),
+        Some(node_config),
+        None,
+    )
+    .await
+    .unwrap();
+    let wallet = wallets.pop().unwrap();
     (
         predicate_code,
         predicate_address,
@@ -32,7 +41,11 @@ async fn create_predicate(
     asset_id: AssetId,
 ) {
     let wallet_coins = wallet
-        .get_asset_inputs_for_amount(asset_id, wallet.get_asset_balance(&asset_id).await.unwrap())
+        .get_asset_inputs_for_amount(
+            asset_id,
+            wallet.get_asset_balance(&asset_id).await.unwrap(),
+            None,
+        )
         .await
         .unwrap();
 
diff --git a/test/src/sdk-harness/test_projects/predicate_data_struct/src/main.sw b/test/src/sdk-harness/test_projects/predicate_data_struct/src/main.sw
index fa1136e3e62..2a977490521 100644
--- a/test/src/sdk-harness/test_projects/predicate_data_struct/src/main.sw
+++ b/test/src/sdk-harness/test_projects/predicate_data_struct/src/main.sw
@@ -8,6 +8,9 @@ struct Validation {
 }
 
 fn main() -> bool {
-    let validation: Validation = input_predicate_data::<Validation>(0);
+    let validation: Validation = match input_predicate_data::<Validation>(0) {
+        Some(data) => data,
+        None => return false,
+    };
     validation.total_complete == 100 && validation.has_account
 }
diff --git a/test/src/sdk-harness/test_projects/run_external_proxy/mod.rs b/test/src/sdk-harness/test_projects/run_external_proxy/mod.rs
index 3b092b43598..d5a25c3e5bb 100644
--- a/test/src/sdk-harness/test_projects/run_external_proxy/mod.rs
+++ b/test/src/sdk-harness/test_projects/run_external_proxy/mod.rs
@@ -1,7 +1,4 @@
-use fuels::{
-    prelude::*,
-    types::Bits256,
-};
+use fuels::{prelude::*, types::Bits256};
 
 abigen!(Contract(
     name = "RunExternalProxyContract",
@@ -9,7 +6,6 @@ abigen!(Contract(
 ));
 
 #[tokio::test]
-#[ignore]
 async fn run_external_can_proxy_call() {
     let wallet = launch_provider_and_get_wallet().await.unwrap();
 
@@ -34,9 +30,7 @@ async fn run_external_can_proxy_call() {
     .deploy(&wallet, TxPolicies::default())
     .await
     .unwrap();
-
     let instance = RunExternalProxyContract::new(id.clone(), wallet);
-
     // Call "large_value"
     // Will call run_external_proxy::large_value
     // that will call run_external_target::large_value
@@ -57,7 +51,6 @@ async fn run_external_can_proxy_call() {
                             print!("{:?} ", s);
                         }
                     }
-
                     println!("{:?}", data);
                 }
             }
@@ -68,7 +61,6 @@ async fn run_external_can_proxy_call() {
         Bits256::from_hex_str("0x00000000000000000000000059F2f1fCfE2474fD5F0b9BA1E73ca90b143Eb8d0")
             .unwrap();
     assert_eq!(result.value, expected_large);
-
     // Call "double_value"
     // Will call run_external_proxy::double_value
     // that will call run_external_target::double_value
@@ -89,7 +81,6 @@ async fn run_external_can_proxy_call() {
                             print!("{:?} ", s);
                         }
                     }
-
                     println!("{:?}", data);
                 }
             }
@@ -97,7 +88,6 @@ async fn run_external_can_proxy_call() {
         }
     }
     assert_eq!(result.value, 84);
-
     // Call "does_not_exist_in_the_target"
     // Will call run_external_proxy::does_not_exist_in_the_target
     // it will proxy the call to run_external_target,
diff --git a/test/src/sdk-harness/test_projects/run_external_proxy/src/main.sw b/test/src/sdk-harness/test_projects/run_external_proxy/src/main.sw
index cadfb1192a6..05dc44f0473 100644
--- a/test/src/sdk-harness/test_projects/run_external_proxy/src/main.sw
+++ b/test/src/sdk-harness/test_projects/run_external_proxy/src/main.sw
@@ -11,7 +11,6 @@ abi RunExternalTest {
     fn large_value() -> b256;
     fn does_not_exist_in_the_target(foo: u64) -> u64;
 }
-
 impl RunExternalTest for Contract {
     fn double_value(_foo: u64) -> u64 {
         __log(1);
@@ -27,4 +26,4 @@ impl RunExternalTest for Contract {
         run_external(TARGET)
     }
     // ANCHOR_END: does_not_exist_in_the_target
-}
+}
\ No newline at end of file
diff --git a/test/src/sdk-harness/test_projects/script_bytecode/src/main.sw b/test/src/sdk-harness/test_projects/script_bytecode/src/main.sw
index 68a45321117..2d9b577e1e9 100644
--- a/test/src/sdk-harness/test_projects/script_bytecode/src/main.sw
+++ b/test/src/sdk-harness/test_projects/script_bytecode/src/main.sw
@@ -15,7 +15,7 @@ impl Hash for [u64; 35] {
 
 fn main() -> b256 {
     // length of return array is script length padded to nearest full word
-    let script_bytecode: [u64; 35] = tx_script_bytecode();
+    let script_bytecode: [u64; 35] = tx_script_bytecode().unwrap();
 
     // Return the hash of the bytecode to compare
     sha256(script_bytecode)
diff --git a/test/src/sdk-harness/test_projects/script_data/mod.rs b/test/src/sdk-harness/test_projects/script_data/mod.rs
index 8dec5042d7d..4768da0f62d 100644
--- a/test/src/sdk-harness/test_projects/script_data/mod.rs
+++ b/test/src/sdk-harness/test_projects/script_data/mod.rs
@@ -9,6 +9,7 @@ async fn call_script(script_data: Vec<u8>) -> Result<Vec<Receipt>> {
         .get_asset_inputs_for_amount(
             AssetId::default(),
             wallet.get_asset_balance(&AssetId::default()).await.unwrap(),
+            None,
         )
         .await
         .unwrap();
diff --git a/test/src/sdk-harness/test_projects/script_data/src/main.sw b/test/src/sdk-harness/test_projects/script_data/src/main.sw
index e61c4f7a205..b31962c175c 100644
--- a/test/src/sdk-harness/test_projects/script_data/src/main.sw
+++ b/test/src/sdk-harness/test_projects/script_data/src/main.sw
@@ -4,13 +4,13 @@ use std::tx::tx_script_data;
 
 fn main() {
     // Reference type
-    let received: b256 = tx_script_data();
+    let received: b256 = tx_script_data().unwrap();
     let expected: b256 = 0xef86afa9696cf0dc6385e2c407a6e159a1103cefb7e2ae0636fb33d3cb2a9e4a;
     log(received);
     assert(received == expected);
 
     // Copy type
-    let received: u64 = tx_script_data();
+    let received: u64 = tx_script_data().unwrap();
     let expected: u64 = 17259675764097085660;
     log(received);
     assert(received == expected);
diff --git a/test/src/sdk-harness/test_projects/storage_namespace/src/main.sw b/test/src/sdk-harness/test_projects/storage_namespace/src/main.sw
index ba63209d76d..043ede1fb74 100644
--- a/test/src/sdk-harness/test_projects/storage_namespace/src/main.sw
+++ b/test/src/sdk-harness/test_projects/storage_namespace/src/main.sw
@@ -47,7 +47,6 @@ const S_13: b256 = 0x00000000000000000000000000000000000000000000000000000000000
 const S_14: b256 = 0x0000000000000000000000000000000000000000000000000000000000000014;
 const S_15: b256 = 0x0000000000000000000000000000000000000000000000000000000000000015;
 
-#[namespace(my_storage_namespace)]
 abi StorageTest {
     #[storage(read, write)]
     fn store_bool(value: bool);
diff --git a/test/src/sdk-harness/test_projects/storage_string/mod.rs b/test/src/sdk-harness/test_projects/storage_string/mod.rs
index 31150ea3476..b84cb090c1c 100644
--- a/test/src/sdk-harness/test_projects/storage_string/mod.rs
+++ b/test/src/sdk-harness/test_projects/storage_string/mod.rs
@@ -7,7 +7,16 @@ abigen!(Contract(
 ));
 
 async fn setup() -> TestStorageStringContract<WalletUnlocked> {
-    let wallet = launch_provider_and_get_wallet().await.unwrap();
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let mut wallets = launch_custom_provider_and_get_wallets(
+        WalletsConfig::new(Some(1), None, None),
+        Some(node_config),
+        None,
+    )
+    .await
+    .unwrap();
+    let wallet = wallets.pop().unwrap();
     let id = Contract::load_from(
         "test_projects/storage_string/out/release/storage_string.bin",
         LoadConfiguration::default(),
diff --git a/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs b/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs
index 3bc7ea5f873..4a5a834f81f 100644
--- a/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs
+++ b/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs
@@ -33,3 +33,11 @@ async fn nested_vec_access_insert() {
 
     methods.nested_vec_access_insert().call().await.unwrap();
 }
+
+#[tokio::test]
+#[should_panic]
+async fn revert_on_load_storage_vec() {
+    let methods = test_storage_vec_nested_instance().await.methods();
+
+    methods.revert_on_load_storage_vec().call().await.unwrap();
+}
diff --git a/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw b/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw
index 7b46cc2e981..122682a6a47 100644
--- a/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw
+++ b/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw
@@ -12,6 +12,9 @@ abi ExperimentalStorageTest {
 
     #[storage(read, write)]
     fn nested_vec_access_insert();
+
+    #[storage(read, write)]
+    fn revert_on_load_storage_vec();
 }
 
 impl ExperimentalStorageTest for Contract {
@@ -47,6 +50,15 @@ impl ExperimentalStorageTest for Contract {
 
         // test_access(inner_vec0, inner_vec1, inner_vec2);
     }
+
+    #[storage(read, write)]
+    fn revert_on_load_storage_vec() {
+        storage.nested_vec.push(StorageVec {});
+        storage.nested_vec.push(StorageVec {});
+        storage.nested_vec.push(StorageVec {});
+
+        let _ =storage.nested_vec.load_vec();
+    }
 }
 
 #[storage(read, write)]
diff --git a/test/src/sdk-harness/test_projects/storage_vec_of_storage_string/mod.rs b/test/src/sdk-harness/test_projects/storage_vec_of_storage_string/mod.rs
index 2fe85042f04..cd15bdd7158 100644
--- a/test/src/sdk-harness/test_projects/storage_vec_of_storage_string/mod.rs
+++ b/test/src/sdk-harness/test_projects/storage_vec_of_storage_string/mod.rs
@@ -6,7 +6,8 @@ abigen!(Contract(
     abi = "test_projects/storage_vec_of_storage_string/out/release/storage_vec_of_storage_string-abi.json",
 ));
 
-async fn test_storage_vec_of_storage_string_instance() -> TestStorageVecOfStorageStringContract<WalletUnlocked> {
+async fn test_storage_vec_of_storage_string_instance(
+) -> TestStorageVecOfStorageStringContract<WalletUnlocked> {
     let wallet = launch_provider_and_get_wallet().await.unwrap();
     let id = Contract::load_from(
         "test_projects/storage_vec_of_storage_string/out/release/storage_vec_of_storage_string.bin",
@@ -26,39 +27,25 @@ async fn test_push_and_get() {
     let instance = test_storage_vec_of_storage_string_instance().await;
 
     const NUM_OF_STRINGS: u64 = 10; // Keep it larger then 8, to stress the internal implementation that does % 8.
-    let strings = (0..NUM_OF_STRINGS).map(|i| i.to_string()).collect::<Vec<_>>();
+    let strings = (0..NUM_OF_STRINGS)
+        .map(|i| i.to_string())
+        .collect::<Vec<_>>();
 
     for string in &strings {
-        let _ = instance
-            .methods()
-            .push(string.to_owned())
-            .call()
-            .await;
+        let _ = instance.methods().push(string.to_owned()).call().await;
     }
 
-    let returned_count = instance
-        .methods()
-        .count()
-        .call()
-        .await
-        .unwrap()
-        .value;
+    let returned_count = instance.methods().count().call().await.unwrap().value;
 
     assert_eq!(returned_count, NUM_OF_STRINGS);
 
     let mut returned_strings = vec![];
     for i in 0..NUM_OF_STRINGS {
-        let returned_string = instance
-            .methods()
-            .get(i)
-            .call()
-            .await
-            .unwrap()
-            .value;
+        let returned_string = instance.methods().get(i).call().await.unwrap().value;
 
         returned_strings.push(returned_string);
     }
-        
+
     assert_eq!(returned_strings, strings);
 }
 
@@ -102,6 +89,6 @@ async fn test_push_and_get() {
 //     }
 
 //     strings.reverse();
-        
+
 //     assert_eq!(returned_strings, strings);
-// }
\ No newline at end of file
+// }
diff --git a/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs b/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs
index f905b6bacbb..a0ef8515fa2 100644
--- a/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs
+++ b/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs
@@ -269,3 +269,70 @@ async fn test_pop_struct() {
     assert_eq!(returned_vec.len(), 3);
     assert_eq!(returned_vec, expected_vec);
 }
+
+#[tokio::test]
+async fn test_conversion_u8() {
+    let instance = test_storage_vec_to_vec_instance().await;
+
+    let test_vec = vec![5u8, 7u8, 9u8, 11u8];
+
+    let _ = instance
+        .methods()
+        .store_vec_u8(test_vec.clone())
+        .call()
+        .await;
+
+    let returned_vec = instance.methods().read_vec_u8().call().await.unwrap().value;
+
+    assert_eq!(returned_vec.len(), 4);
+    assert_eq!(returned_vec, test_vec);
+}
+
+#[tokio::test]
+async fn test_push_u8() {
+    let instance = test_storage_vec_to_vec_instance().await;
+
+    let test_vec = vec![5u8, 7u8, 9u8, 11u8];
+
+    let _ = instance
+        .methods()
+        .store_vec_u8(test_vec.clone())
+        .call()
+        .await;
+
+    let _ = instance.methods().push_vec_u8(13u8).call().await;
+
+    let returned_vec = instance.methods().read_vec_u8().call().await.unwrap().value;
+
+    let mut expected_vec = test_vec;
+    expected_vec.push(13u8);
+
+    assert_eq!(returned_vec.len(), 5);
+    assert_eq!(returned_vec, expected_vec);
+}
+
+#[tokio::test]
+async fn test_pop_u8() {
+    let instance = test_storage_vec_to_vec_instance().await;
+
+    let test_vec = vec![5u8, 7u8, 9u8, 11u8];
+
+    let _ = instance
+        .methods()
+        .store_vec_u8(test_vec.clone())
+        .call()
+        .await;
+
+    assert_eq!(
+        11u8,
+        instance.methods().pop_vec_u8().call().await.unwrap().value
+    );
+
+    let returned_vec = instance.methods().read_vec_u8().call().await.unwrap().value;
+
+    let mut expected_vec = test_vec;
+    expected_vec.pop();
+
+    assert_eq!(returned_vec.len(), 3);
+    assert_eq!(returned_vec, expected_vec);
+}
diff --git a/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw b/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw
index ef7dc027464..9e2f3241030 100644
--- a/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw
+++ b/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw
@@ -17,6 +17,7 @@ impl Eq for TestStruct {
 storage {
     storage_vec_u64: StorageVec<u64> = StorageVec {},
     storage_vec_struct: StorageVec<TestStruct> = StorageVec {},
+    storage_vec_u8: StorageVec<u8> = StorageVec {},
 }
 
 abi VecToVecStorageTest {
@@ -36,6 +37,14 @@ abi VecToVecStorageTest {
     fn push_vec_struct(val: TestStruct);
     #[storage(read, write)]
     fn pop_vec_struct() -> TestStruct;
+    #[storage(read, write)]
+    fn store_vec_u8(vec: Vec<u8>);
+    #[storage(read)]
+    fn read_vec_u8() -> Vec<u8>;
+    #[storage(read, write)]
+    fn push_vec_u8(val: u8);
+    #[storage(read, write)]
+    fn pop_vec_u8() -> u8;
 }
 
 impl VecToVecStorageTest for Contract {
@@ -82,287 +91,24 @@ impl VecToVecStorageTest for Contract {
             val3: 0,
         })
     }
-}
-
-#[test]
-fn test_conversion_u64() {
-    let vec_abi = abi(VecToVecStorageTest, CONTRACT_ID);
-    let mut test_vec = Vec::<u64>::new();
-    test_vec.push(5);
-    test_vec.push(7);
-    test_vec.push(9);
-    test_vec.push(11);
-
-    vec_abi.store_vec_u64(test_vec);
-
-    let returned_vec = vec_abi.read_vec_u64();
-
-    assert(returned_vec.len() == 4);
-    assert(returned_vec.get(0).unwrap() == 5);
-    assert(returned_vec.get(1).unwrap() == 7);
-    assert(returned_vec.get(2).unwrap() == 9);
-    assert(returned_vec.get(3).unwrap() == 11);
-}
-
-#[test]
-fn test_push_u64() {
-    let vec_abi = abi(VecToVecStorageTest, CONTRACT_ID);
-    let mut test_vec = Vec::<u64>::new();
-    test_vec.push(5);
-    test_vec.push(7);
-    test_vec.push(9);
-    test_vec.push(11);
-
-    vec_abi.store_vec_u64(test_vec);
-
-    vec_abi.push_vec_u64(13);
-
-    let returned_vec = vec_abi.read_vec_u64();
-
-    assert(returned_vec.len() == 5);
-    assert(returned_vec.get(0).unwrap() == 5);
-    assert(returned_vec.get(1).unwrap() == 7);
-    assert(returned_vec.get(2).unwrap() == 9);
-    assert(returned_vec.get(3).unwrap() == 11);
-    assert(returned_vec.get(4).unwrap() == 13);
-}
-
-#[test]
-fn test_pop_u64() {
-    let vec_abi = abi(VecToVecStorageTest, CONTRACT_ID);
-    let mut test_vec = Vec::<u64>::new();
-    test_vec.push(5);
-    test_vec.push(7);
-    test_vec.push(9);
-    test_vec.push(11);
-
-    vec_abi.store_vec_u64(test_vec);
-
-    assert(11 == vec_abi.pop_vec_u64());
-
-    let returned_vec = vec_abi.read_vec_u64();
-
-    assert(returned_vec.len() == 3);
-    assert(returned_vec.get(0).unwrap() == 5);
-    assert(returned_vec.get(1).unwrap() == 7);
-    assert(returned_vec.get(2).unwrap() == 9);
-}
-
-#[test]
-fn test_conversion_struct() {
-    let vec_abi = abi(VecToVecStorageTest, CONTRACT_ID);
-    let mut test_vec = Vec::<TestStruct>::new();
-    test_vec.push(TestStruct {
-        val1: 0,
-        val2: 1,
-        val3: 2,
-    });
-    test_vec.push(TestStruct {
-        val1: 1,
-        val2: 2,
-        val3: 3,
-    });
-    test_vec.push(TestStruct {
-        val1: 2,
-        val2: 3,
-        val3: 4,
-    });
-    test_vec.push(TestStruct {
-        val1: 3,
-        val2: 4,
-        val3: 5,
-    });
 
-    vec_abi.store_vec_struct(test_vec);
-
-    let returned_vec = vec_abi.read_vec_struct();
-
-    assert(returned_vec.len() == 4);
-    assert(
-        returned_vec
-            .get(0)
-            .unwrap() == TestStruct {
-            val1: 0,
-            val2: 1,
-            val3: 2,
-        },
-    );
-    assert(
-        returned_vec
-            .get(1)
-            .unwrap() == TestStruct {
-            val1: 1,
-            val2: 2,
-            val3: 3,
-        },
-    );
-    assert(
-        returned_vec
-            .get(2)
-            .unwrap() == TestStruct {
-            val1: 2,
-            val2: 3,
-            val3: 4,
-        },
-    );
-    assert(
-        returned_vec
-            .get(3)
-            .unwrap() == TestStruct {
-            val1: 3,
-            val2: 4,
-            val3: 5,
-        },
-    );
-}
-
-#[test]
-fn test_push_struct() {
-    let vec_abi = abi(VecToVecStorageTest, CONTRACT_ID);
-    let mut test_vec = Vec::<TestStruct>::new();
-    test_vec.push(TestStruct {
-        val1: 0,
-        val2: 1,
-        val3: 2,
-    });
-    test_vec.push(TestStruct {
-        val1: 1,
-        val2: 2,
-        val3: 3,
-    });
-    test_vec.push(TestStruct {
-        val1: 2,
-        val2: 3,
-        val3: 4,
-    });
-    test_vec.push(TestStruct {
-        val1: 3,
-        val2: 4,
-        val3: 5,
-    });
-
-    vec_abi.store_vec_struct(test_vec);
-
-    vec_abi.push_vec_struct(TestStruct {
-        val1: 4,
-        val2: 5,
-        val3: 6,
-    });
-
-    let returned_vec = vec_abi.read_vec_struct();
-
-    assert(returned_vec.len() == 5);
-    assert(
-        returned_vec
-            .get(0)
-            .unwrap() == TestStruct {
-            val1: 0,
-            val2: 1,
-            val3: 2,
-        },
-    );
-    assert(
-        returned_vec
-            .get(1)
-            .unwrap() == TestStruct {
-            val1: 1,
-            val2: 2,
-            val3: 3,
-        },
-    );
-    assert(
-        returned_vec
-            .get(2)
-            .unwrap() == TestStruct {
-            val1: 2,
-            val2: 3,
-            val3: 4,
-        },
-    );
-    assert(
-        returned_vec
-            .get(3)
-            .unwrap() == TestStruct {
-            val1: 3,
-            val2: 4,
-            val3: 5,
-        },
-    );
-    assert(
-        returned_vec
-            .get(4)
-            .unwrap() == TestStruct {
-            val1: 4,
-            val2: 5,
-            val3: 6,
-        },
-    );
-}
-
-#[test]
-fn test_pop_struct() {
-    let vec_abi = abi(VecToVecStorageTest, CONTRACT_ID);
-    let mut test_vec = Vec::<TestStruct>::new();
-    test_vec.push(TestStruct {
-        val1: 0,
-        val2: 1,
-        val3: 2,
-    });
-    test_vec.push(TestStruct {
-        val1: 1,
-        val2: 2,
-        val3: 3,
-    });
-    test_vec.push(TestStruct {
-        val1: 2,
-        val2: 3,
-        val3: 4,
-    });
-    test_vec.push(TestStruct {
-        val1: 3,
-        val2: 4,
-        val3: 5,
-    });
-
-    vec_abi.store_vec_struct(test_vec);
+    #[storage(read, write)]
+    fn store_vec_u8(vec: Vec<u8>) {
+        storage.storage_vec_u8.store_vec(vec);
+    }
 
-    assert(
-        TestStruct {
-            val1: 3,
-            val2: 4,
-            val3: 5,
-        } == vec_abi
-            .pop_vec_struct(),
-    );
+    #[storage(read)]
+    fn read_vec_u8() -> Vec<u8> {
+        storage.storage_vec_u8.load_vec()
+    }
 
-    let returned_vec = vec_abi.read_vec_struct();
+    #[storage(read, write)]
+    fn push_vec_u8(val: u8) {
+        storage.storage_vec_u8.push(val);
+    }
 
-    assert(returned_vec.len() == 3);
-    assert(
-        returned_vec
-            .get(0)
-            .unwrap() == TestStruct {
-            val1: 0,
-            val2: 1,
-            val3: 2,
-        },
-    );
-    assert(
-        returned_vec
-            .get(1)
-            .unwrap() == TestStruct {
-            val1: 1,
-            val2: 2,
-            val3: 3,
-        },
-    );
-    assert(
-        returned_vec
-            .get(2)
-            .unwrap() == TestStruct {
-            val1: 2,
-            val2: 3,
-            val3: 4,
-        },
-    );
+    #[storage(read, write)]
+    fn pop_vec_u8() -> u8 {
+        storage.storage_vec_u8.pop().unwrap_or(0)
+    }
 }
diff --git a/test/src/sdk-harness/test_projects/string_slice/mod.rs b/test/src/sdk-harness/test_projects/string_slice/mod.rs
new file mode 100644
index 00000000000..5f56b0f1ce4
--- /dev/null
+++ b/test/src/sdk-harness/test_projects/string_slice/mod.rs
@@ -0,0 +1,167 @@
+use fuel_vm::fuel_asm::{op, RegId};
+use fuel_vm::fuel_tx;
+use fuel_vm::fuel_tx::{Address, AssetId, Output};
+use fuels::types::StaticStringToken;
+use fuels::{
+    accounts::wallet::{Wallet, WalletUnlocked},
+    core::codec::{ABIEncoder, EncoderConfig},
+    prelude::*,
+    types::{input::Input, transaction_builders::ScriptTransactionBuilder, Token},
+};
+use std::str::FromStr;
+
+abigen!(Contract(
+    name = "TestStringSlicePredicate",
+    abi = "test_projects/string_slice/string_slice_predicate/out/release/string_slice_predicate-abi.json",
+));
+
+async fn setup() -> (Vec<u8>, Address, WalletUnlocked, u64, AssetId) {
+    let predicate_code = std::fs::read(
+        "test_projects/string_slice/string_slice_predicate/out/release/string_slice_predicate.bin",
+    )
+    .unwrap();
+    let predicate_address = fuel_tx::Input::predicate_owner(&predicate_code);
+
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let mut wallets = launch_custom_provider_and_get_wallets(
+        WalletsConfig::new(Some(1), None, None),
+        Some(node_config),
+        None,
+    )
+    .await
+    .unwrap();
+    let wallet = wallets.pop().unwrap();
+    (
+        predicate_code,
+        predicate_address,
+        wallet,
+        1000,
+        AssetId::default(),
+    )
+}
+
+async fn create_predicate(
+    predicate_address: Address,
+    wallet: &WalletUnlocked,
+    amount_to_predicate: u64,
+    asset_id: AssetId,
+) {
+    let wallet_coins = wallet
+        .get_asset_inputs_for_amount(
+            asset_id,
+            wallet.get_asset_balance(&asset_id).await.unwrap(),
+            None,
+        )
+        .await
+        .unwrap();
+
+    let provider = wallet.provider().unwrap();
+    let output_coin = Output::coin(predicate_address, amount_to_predicate, asset_id);
+    let output_change = Output::change(wallet.address().into(), 0, asset_id);
+    let mut tx = ScriptTransactionBuilder::prepare_transfer(
+        wallet_coins,
+        vec![output_coin, output_change],
+        Default::default(),
+    )
+    .with_script(op::ret(RegId::ONE).to_bytes().to_vec());
+
+    tx.add_signer(wallet.clone()).unwrap();
+    let tx = tx.build(provider).await.unwrap();
+    provider.send_transaction(tx).await.unwrap();
+}
+
+async fn get_balance(wallet: &Wallet, address: Address, asset_id: AssetId) -> u64 {
+    wallet
+        .provider()
+        .unwrap()
+        .get_asset_balance(&address.into(), asset_id)
+        .await
+        .unwrap()
+}
+
+async fn submit_to_predicate(
+    predicate_code: Vec<u8>,
+    predicate_address: Address,
+    wallet: &Wallet,
+    amount_to_predicate: u64,
+    asset_id: AssetId,
+    receiver_address: Address,
+    predicate_data: Vec<u8>,
+) {
+    let filter = ResourceFilter {
+        from: predicate_address.into(),
+        asset_id: Some(asset_id),
+        amount: amount_to_predicate,
+        ..Default::default()
+    };
+    let provider = wallet.provider().unwrap();
+
+    let utxo_predicate_hash = provider.get_spendable_resources(filter).await.unwrap();
+
+    let mut inputs = vec![];
+    let mut total_amount_in_predicate = 0;
+
+    for coin in utxo_predicate_hash {
+        inputs.push(Input::resource_predicate(
+            coin.clone(),
+            predicate_code.to_vec(),
+            predicate_data.clone(),
+        ));
+        total_amount_in_predicate += coin.amount();
+    }
+
+    let output_coin = Output::coin(receiver_address, total_amount_in_predicate, asset_id);
+    let output_change = Output::change(predicate_address, 0, asset_id);
+
+    let new_tx = ScriptTransactionBuilder::prepare_transfer(
+        inputs,
+        vec![output_coin, output_change],
+        Default::default(),
+    )
+    .build(provider)
+    .await
+    .unwrap();
+
+    let _call_result = provider.send_transaction(new_tx).await;
+}
+
+#[tokio::test]
+async fn test_string_slice_predicate() {
+    let predicate_data = ABIEncoder::new(EncoderConfig::default())
+        .encode(&[Token::StringSlice(StaticStringToken::new(
+            "a".into(),
+            Some(1),
+        ))])
+        .unwrap();
+
+    let receiver_address =
+        Address::from_str("0xde97d8624a438121b86a1956544bd72ed68cd69f2c99555b08b1e8c51ffd511c")
+            .unwrap();
+    let (predicate_code, predicate_address, wallet, amount_to_predicate, asset_id) = setup().await;
+
+    create_predicate(predicate_address, &wallet, amount_to_predicate, asset_id).await;
+
+    let receiver_balance_before = get_balance(&wallet, receiver_address, asset_id).await;
+    assert_eq!(receiver_balance_before, 0);
+
+    submit_to_predicate(
+        predicate_code,
+        predicate_address,
+        &wallet,
+        amount_to_predicate,
+        asset_id,
+        receiver_address,
+        predicate_data,
+    )
+    .await;
+
+    let receiver_balance_after = get_balance(&wallet, receiver_address, asset_id).await;
+    assert_eq!(
+        receiver_balance_before + amount_to_predicate,
+        receiver_balance_after
+    );
+
+    let predicate_balance = get_balance(&wallet, predicate_address, asset_id).await;
+    assert_eq!(predicate_balance, 0);
+}
diff --git a/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/Forc.lock b/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/Forc.lock
new file mode 100644
index 00000000000..a629d094533
--- /dev/null
+++ b/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-A528390DA52F2C73"
+
+[[package]]
+name = "string_slice_script"
+source = "member"
+dependencies = ["core"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/Forc.toml b/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/Forc.toml
similarity index 83%
rename from test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/Forc.toml
rename to test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/Forc.toml
index 60125668f58..d8909e8bd09 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/str_slice_script/Forc.toml
+++ b/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/Forc.toml
@@ -1,8 +1,8 @@
 [project]
-name = "str_slice_script"
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
+name = "string_slice_predicate"
 
 [dependencies]
 core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/src/main.sw b/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/src/main.sw
new file mode 100644
index 00000000000..5f461df69ac
--- /dev/null
+++ b/test/src/sdk-harness/test_projects/string_slice/string_slice_predicate/src/main.sw
@@ -0,0 +1,5 @@
+predicate;
+
+fn main(a: str) -> bool {
+    a == "a"
+}
diff --git a/test/src/sdk-harness/test_projects/superabi_supertrait/mod.rs b/test/src/sdk-harness/test_projects/superabi_supertrait/mod.rs
index 09db2de6399..5f6b8d8365a 100644
--- a/test/src/sdk-harness/test_projects/superabi_supertrait/mod.rs
+++ b/test/src/sdk-harness/test_projects/superabi_supertrait/mod.rs
@@ -30,13 +30,14 @@ async fn method1_test() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-async fn method_test() -> Result<()> {
-    let instance = get_superabi_supertrait_instance().await;
-    let contract_methods = instance.methods();
+// contract supertrait methods are not callable externally
+// #[tokio::test]
+// async fn method_test() -> Result<()> {
+//     let instance = get_superabi_supertrait_instance().await;
+//     let contract_methods = instance.methods();
 
-    let response = contract_methods.method().call().await?;
-    assert_eq!(0xBAD, response.value);
+//     let response = contract_methods.method().call().await?;
+//     assert_eq!(0xBAD, response.value);
 
-    Ok(())
-}
+//     Ok(())
+// }
diff --git a/test/src/sdk-harness/test_projects/tx_fields/mod.rs b/test/src/sdk-harness/test_projects/tx_fields/mod.rs
index c83fb9977ba..0ac934999c7 100644
--- a/test/src/sdk-harness/test_projects/tx_fields/mod.rs
+++ b/test/src/sdk-harness/test_projects/tx_fields/mod.rs
@@ -1,19 +1,45 @@
 use fuel_vm::fuel_crypto::Hasher;
-use fuel_vm::fuel_tx::{Bytes32, ConsensusParameters, ContractId, Input as TxInput};
+use fuel_vm::fuel_tx::{ContractId, Input as TxInput};
+use fuels::core::codec::EncoderConfig;
 use fuels::types::transaction_builders::TransactionBuilder;
 use fuels::{
     accounts::{predicate::Predicate, wallet::WalletUnlocked, Account},
     prelude::*,
-    types::{input::Input as SdkInput, Bits256},
+    tx::StorageSlot,
+    types::{input::Input as SdkInput, output::Output as SdkOutput, Bits256},
 };
+use std::fs;
 
 const MESSAGE_DATA: [u8; 3] = [1u8, 2u8, 3u8];
+const TX_CONTRACT_BYTECODE_PATH: &str = "test_artifacts/tx_contract/out/release/tx_contract.bin";
+const TX_OUTPUT_PREDICATE_BYTECODE_PATH: &str =
+    "test_artifacts/tx_output_predicate/out/release/tx_output_predicate.bin";
+const TX_OUTPUT_CHANGE_CONTRACT_BYTECODE_PATH: &str =
+    "test_artifacts/tx_output_change_contract/out/release/tx_output_change_contract.bin";
+const TX_FIELDS_PREDICATE_BYTECODE_PATH: &str = "test_projects/tx_fields/out/release/tx_fields.bin";
+const TX_CONTRACT_CREATION_PREDICATE_BYTECODE_PATH: &str =
+    "test_artifacts/tx_output_contract_creation_predicate/out/release/tx_output_contract_creation_predicate.bin";
+const TX_TYPE_PREDICATE_BYTECODE_PATH: &str =
+    "test_artifacts/tx_type_predicate/out/release/tx_type_predicate.bin";
+const TX_WITNESS_PREDICATE_BYTECODE_PATH: &str =
+    "test_artifacts/tx_witness_predicate/out/release/tx_witness_predicate.bin";
+const TX_INPUT_COUNT_PREDICATE_BYTECODE_PATH: &str =
+    "test_artifacts/tx_input_count_predicate/out/release/tx_input_count_predicate.bin";
+const TX_OUTPUT_COUNT_PREDICATE_BYTECODE_PATH: &str =
+    "test_artifacts/tx_output_count_predicate/out/release/tx_output_count_predicate.bin";
+
+use crate::tx_fields::Transaction as SwayTransaction;
+use crate::tx_fields::Output as SwayOutput;
 
 abigen!(
     Contract(
         name = "TxContractTest",
         abi = "test_artifacts/tx_contract/out/release/tx_contract-abi.json",
     ),
+    Contract(
+        name = "TxOutputChangeContract",
+        abi = "test_artifacts/tx_output_change_contract/out/release/tx_output_change_contract-abi.json",
+    ),
     Predicate(
         name = "TestPredicate",
         abi = "test_projects/tx_fields/out/release/tx_fields-abi.json"
@@ -21,6 +47,22 @@ abigen!(
     Predicate(
         name = "TestOutputPredicate",
         abi = "test_artifacts/tx_output_predicate/out/release/tx_output_predicate-abi.json"
+    ),
+    Predicate(
+        name = "TestTxTypePredicate",
+        abi = "test_artifacts/tx_type_predicate/out/release/tx_type_predicate-abi.json"
+    ),
+    Predicate(
+        name = "TestTxWitnessPredicate",
+        abi = "test_artifacts/tx_witness_predicate/out/release/tx_witness_predicate-abi.json"
+    ),
+    Predicate(
+        name = "TestTxInputCountPredicate",
+        abi = "test_artifacts/tx_input_count_predicate/out/release/tx_input_count_predicate-abi.json"
+    ),
+    Predicate(
+        name = "TestTxOutputCountPredicate",
+        abi = "test_artifacts/tx_output_count_predicate/out/release/tx_output_count_predicate-abi.json"
     )
 );
 
@@ -68,14 +110,11 @@ async fn get_contracts(
     wallet.set_provider(provider.clone());
     deployment_wallet.set_provider(provider);
 
-    let contract_id = Contract::load_from(
-        "test_artifacts/tx_contract/out/release/tx_contract.bin",
-        LoadConfiguration::default(),
-    )
-    .unwrap()
-    .deploy(&wallet, TxPolicies::default())
-    .await
-    .unwrap();
+    let contract_id = Contract::load_from(TX_CONTRACT_BYTECODE_PATH, LoadConfiguration::default())
+        .unwrap()
+        .deploy(&wallet, TxPolicies::default())
+        .await
+        .unwrap();
 
     let instance = TxContractTest::new(contract_id.clone(), deployment_wallet.clone());
 
@@ -87,7 +126,7 @@ async fn generate_predicate_inputs(
     wallet: &WalletUnlocked,
 ) -> (Vec<u8>, SdkInput, TxInput) {
     let provider = wallet.provider().unwrap();
-    let predicate = Predicate::load_from("test_projects/tx_fields/out/release/tx_fields.bin")
+    let predicate = Predicate::load_from(TX_FIELDS_PREDICATE_BYTECODE_PATH)
         .unwrap()
         .with_provider(provider.clone());
 
@@ -110,7 +149,7 @@ async fn generate_predicate_inputs(
         .unwrap();
 
     let predicate_input = predicate
-        .get_asset_inputs_for_amount(AssetId::default(), amount)
+        .get_asset_inputs_for_amount(AssetId::default(), amount, None)
         .await
         .unwrap()
         .first()
@@ -133,7 +172,7 @@ async fn generate_predicate_inputs(
     (predicate_code, predicate_input, predicate_message)
 }
 
-async fn setup_output_predicate() -> (WalletUnlocked, WalletUnlocked, Predicate, AssetId, AssetId) {
+async fn setup_output_predicate(index: u64, expected_output_type: SwayOutput) -> (WalletUnlocked, WalletUnlocked, Predicate, AssetId, AssetId) {
     let asset_id1 = AssetId::default();
     let asset_id2 = AssetId::new([2u8; 32]);
     let wallets_config = WalletsConfig::new_multiple_assets(
@@ -152,22 +191,23 @@ async fn setup_output_predicate() -> (WalletUnlocked, WalletUnlocked, Predicate,
         ],
     );
 
-    let mut wallets = launch_custom_provider_and_get_wallets(wallets_config, None, None)
-        .await
-        .unwrap();
+    let mut node_config = NodeConfig::default();
+    node_config.starting_gas_price = 0;
+    let mut wallets =
+        launch_custom_provider_and_get_wallets(wallets_config, Some(node_config), None)
+            .await
+            .unwrap();
     let wallet1 = wallets.pop().unwrap();
     let wallet2 = wallets.pop().unwrap();
 
     let predicate_data = TestOutputPredicateEncoder::default()
-        .encode_data(0, Bits256([0u8; 32]), Bits256(*wallet1.address().hash()))
+        .encode_data(index, Bits256([0u8; 32]), Bits256(*wallet1.address().hash()), expected_output_type)
         .unwrap();
 
-    let predicate = Predicate::load_from(
-        "test_artifacts/tx_output_predicate/out/release/tx_output_predicate.bin",
-    )
-    .unwrap()
-    .with_data(predicate_data)
-    .with_provider(wallet1.try_provider().unwrap().clone());
+    let predicate = Predicate::load_from(TX_OUTPUT_PREDICATE_BYTECODE_PATH)
+        .unwrap()
+        .with_data(predicate_data)
+        .with_provider(wallet1.try_provider().unwrap().clone());
 
     wallet1
         .transfer(predicate.address(), 100, asset_id1, TxPolicies::default())
@@ -184,7 +224,6 @@ async fn setup_output_predicate() -> (WalletUnlocked, WalletUnlocked, Predicate,
 
 mod tx {
     use super::*;
-    use fuel_vm::fuel_tx::field::Script;
     use fuels::types::{coin_type::CoinType, transaction::Transaction};
 
     #[tokio::test]
@@ -214,7 +253,16 @@ mod tx {
             .await
             .unwrap();
 
-        assert_eq!(result.value, tip);
+        assert_eq!(result.value, Some(tip));
+
+        let no_tip = contract_instance
+            .methods()
+            .get_tx_tip()
+            .call()
+            .await
+            .unwrap();
+
+        assert_eq!(no_tip.value, None);
     }
 
     #[tokio::test]
@@ -245,7 +293,16 @@ mod tx {
             .call()
             .await
             .unwrap();
-        assert_eq!(result.value, maturity);
+        assert_eq!(result.value, Some(maturity as u32));
+
+        // Assert none is returned with no maturity
+        let no_maturity = contract_instance
+            .methods()
+            .get_tx_maturity()
+            .call()
+            .await
+            .unwrap();
+        assert_eq!(no_maturity.value, None);
     }
 
     #[tokio::test]
@@ -260,7 +317,7 @@ mod tx {
             .call()
             .await
             .unwrap();
-        assert_eq!(result.value, script_length);
+        assert_eq!(result.value, Some(script_length));
     }
 
     #[tokio::test]
@@ -275,7 +332,7 @@ mod tx {
             .call()
             .await
             .unwrap();
-        assert_eq!(result.value, script_data_length);
+        assert_eq!(result.value, Some(script_data_length));
     }
 
     #[tokio::test]
@@ -333,7 +390,7 @@ mod tx {
             .await
             .unwrap();
 
-        assert_eq!(result.value, outputs.len() as u64);
+        assert_eq!(result.value, outputs.len() as u16);
     }
 
     #[tokio::test]
@@ -351,20 +408,6 @@ mod tx {
         assert_eq!(result.value, witnesses_count);
     }
 
-    #[tokio::test]
-    async fn can_get_witness_pointer() {
-        let (contract_instance, _, _, _) = get_contracts(true).await;
-
-        let response = contract_instance
-            .methods()
-            .get_tx_witness_pointer(0)
-            .call()
-            .await
-            .unwrap();
-
-        assert_eq!(response.value, 11024);
-    }
-
     #[tokio::test]
     async fn can_get_witness_data_length() {
         let (contract_instance, _, _, _) = get_contracts(true).await;
@@ -376,7 +419,7 @@ mod tx {
             .await
             .unwrap();
 
-        assert_eq!(result.value, 64);
+        assert_eq!(result.value, Some(64));
     }
 
     #[tokio::test]
@@ -396,23 +439,7 @@ mod tx {
             .take_receipts_checked(None)
             .unwrap();
 
-        assert_eq!(receipts[1].data().unwrap(), witnesses[0].as_vec());
-    }
-
-    #[tokio::test]
-    async fn can_get_script_start_offset() {
-        let (contract_instance, _, _, _) = get_contracts(true).await;
-
-        let script_start_offset = ConsensusParameters::default().tx_params().tx_offset()
-            + fuel_vm::fuel_tx::Script::script_offset_static();
-
-        let result = contract_instance
-            .methods()
-            .get_tx_script_start_pointer()
-            .call()
-            .await
-            .unwrap();
-        assert_eq!(result.value, script_start_offset as u64);
+        assert_eq!(receipts[1].data().unwrap()[8..72], *witnesses[0].as_vec());
     }
 
     #[tokio::test]
@@ -439,7 +466,7 @@ mod tx {
             .call()
             .await
             .unwrap();
-        assert_eq!(Bytes32::from(result.value.0), hash);
+        assert_eq!(result.value.unwrap(), Bits256(*hash));
     }
 
     #[tokio::test]
@@ -464,43 +491,219 @@ mod tx {
     }
 
     #[tokio::test]
-    async fn can_get_get_tx_script_data_start_pointer() {
-        let (contract_instance, _, _, _) = get_contracts(true).await;
-        let result = contract_instance
-            .methods()
-            .get_tx_script_data_start_pointer()
-            .call()
+    async fn can_get_tx_upload() {
+        // Prepare wallet and provider
+        let mut wallet = WalletUnlocked::new_random(None);
+        let num_coins = 100;
+        let coins = setup_single_asset_coins(
+            wallet.address(),
+            AssetId::zeroed(),
+            num_coins,
+            DEFAULT_COIN_AMOUNT,
+        );
+        let provider = setup_test_provider(coins, vec![], None, None)
             .await
             .unwrap();
-        assert_eq!(result.value, 10392)
+        wallet.set_provider(provider.clone());
+
+        // Get the predicate
+        let predicate_data = TestTxTypePredicateEncoder::default()
+            .encode_data(SwayTransaction::Upload)
+            .unwrap();
+        let predicate: Predicate = Predicate::load_from(TX_TYPE_PREDICATE_BYTECODE_PATH)
+            .unwrap()
+            .with_provider(provider.clone())
+            .with_data(predicate_data);
+        let predicate_coin_amount = 100;
+
+        // Predicate has no funds
+        let predicate_balance = predicate
+            .get_asset_balance(&provider.base_asset_id())
+            .await
+            .unwrap();
+        assert_eq!(predicate_balance, 0);
+
+        // Prepare bytecode and subsections
+        let bytecode = fs::read(TX_CONTRACT_BYTECODE_PATH).unwrap();
+        let subsection_size = 65536;
+        let subsections = UploadSubsection::split_bytecode(&bytecode, subsection_size).unwrap();
+
+        // Transfer enough funds to the predicate for each subsection
+        for _ in subsections.clone() {
+            wallet
+                .transfer(
+                    predicate.address(),
+                    predicate_coin_amount,
+                    *provider.base_asset_id(),
+                    TxPolicies::default(),
+                )
+                .await
+                .unwrap();
+        }
+
+        // Predicate has funds
+        let predicate_balance = predicate
+            .get_asset_balance(&provider.base_asset_id())
+            .await
+            .unwrap();
+        assert_eq!(
+            predicate_balance as usize,
+            predicate_coin_amount as usize * subsections.len()
+        );
+
+        // Upload each sub section in a separate transaction and include the predicate with the transaction.
+        for subsection in subsections {
+            let mut builder = UploadTransactionBuilder::prepare_subsection_upload(
+                subsection,
+                TxPolicies::default(),
+            );
+
+            // Inputs for predicate
+            let predicate_input = predicate
+                .get_asset_inputs_for_amount(*provider.base_asset_id(), 1, None)
+                .await
+                .unwrap();
+
+            // Outputs for predicate
+            let predicate_output = wallet.get_asset_outputs_for_amount(
+                &wallet.address(),
+                *provider.base_asset_id(),
+                1,
+            );
+
+            // Append the predicate to the transaction
+            builder.inputs.push(predicate_input.get(0).unwrap().clone());
+            builder
+                .outputs
+                .push(predicate_output.get(0).unwrap().clone());
+
+            wallet.add_witnesses(&mut builder).unwrap();
+            wallet.adjust_for_fee(&mut builder, 0).await.unwrap();
+
+            // Submit the transaction
+            let tx = builder.build(&provider).await.unwrap();
+            provider.send_transaction(tx).await.unwrap();
+        }
+
+        // The predicate has spent it's funds
+        let predicate_balance = predicate
+            .get_asset_balance(&provider.base_asset_id())
+            .await
+            .unwrap();
+        assert_eq!(predicate_balance, 0);
     }
-}
 
-mod inputs {
-    use super::*;
+    #[tokio::test]
+    async fn can_get_witness_in_tx_upload() {
+        // Prepare wallet and provider
+        let mut wallet = WalletUnlocked::new_random(None);
+        let num_coins = 100;
+        let coins = setup_single_asset_coins(
+            wallet.address(),
+            AssetId::zeroed(),
+            num_coins,
+            DEFAULT_COIN_AMOUNT,
+        );
+        let provider = setup_test_provider(coins, vec![], None, None)
+            .await
+            .unwrap();
+        wallet.set_provider(provider.clone());
+
+        // Prepare bytecode and subsections
+        let bytecode = fs::read(TX_CONTRACT_BYTECODE_PATH).unwrap();
+        let subsection_size = 65536;
+        let subsections = UploadSubsection::split_bytecode(&bytecode, subsection_size).unwrap();
+
+        // Upload each sub section in a separate transaction and include the predicate with the transaction.
+        for subsection in subsections.clone() {
+            let mut builder = UploadTransactionBuilder::prepare_subsection_upload(
+                subsection,
+                TxPolicies::default(),
+            );
+
+            // Prepare the predicate
+            let witnesses = builder.witnesses().clone();
+            let predicate_data = TestTxWitnessPredicateEncoder::new(EncoderConfig {
+                max_depth: 10,
+                max_tokens: 100_000,
+            })
+            .encode_data(
+                0,
+                witnesses.len() as u64 + 1,
+                witnesses[0].as_vec().len() as u64,
+                witnesses[0].as_vec().as_slice()[0..64].try_into().unwrap(),
+            )
+            .unwrap();
+            let predicate: Predicate = Predicate::load_from(TX_WITNESS_PREDICATE_BYTECODE_PATH)
+                .unwrap()
+                .with_provider(provider.clone())
+                .with_data(predicate_data);
+            let predicate_coin_amount = 100;
 
-    mod revert {
-        use super::*;
+            // Predicate has no funds
+            let predicate_balance = predicate
+                .get_asset_balance(&provider.base_asset_id())
+                .await
+                .unwrap();
+            assert_eq!(predicate_balance, 0);
+            wallet
+                .transfer(
+                    predicate.address(),
+                    predicate_coin_amount,
+                    *provider.base_asset_id(),
+                    TxPolicies::default(),
+                )
+                .await
+                .unwrap();
 
-        mod contract {
-            use super::*;
+            // Predicate has funds
+            let predicate_balance = predicate
+                .get_asset_balance(&provider.base_asset_id())
+                .await
+                .unwrap();
+            assert_eq!(
+                predicate_balance as usize,
+                predicate_coin_amount as usize * subsections.len()
+            );
+
+            // Inputs for predicate
+            let predicate_input = predicate
+                .get_asset_inputs_for_amount(*provider.base_asset_id(), 1, None)
+                .await
+                .unwrap();
 
-            #[tokio::test]
-            #[should_panic(expected = "Revert(0)")]
-            async fn fails_to_get_predicate_data_pointer_from_input_contract() {
-                let (contract_instance, _, _, _) = get_contracts(true).await;
-                let call_params = CallParameters::default();
-                contract_instance
-                    .methods()
-                    .get_tx_input_predicate_data_pointer(0)
-                    .call_params(call_params)
-                    .unwrap()
-                    .call()
-                    .await
-                    .unwrap();
-            }
+            // Outputs for predicate
+            let predicate_output = wallet.get_asset_outputs_for_amount(
+                &wallet.address(),
+                *provider.base_asset_id(),
+                1,
+            );
+
+            // Append the predicate to the transaction
+            builder.inputs.push(predicate_input.get(0).unwrap().clone());
+            builder
+                .outputs
+                .push(predicate_output.get(0).unwrap().clone());
+
+            wallet.add_witnesses(&mut builder).unwrap();
+            wallet.adjust_for_fee(&mut builder, 0).await.unwrap();
+
+            // Submit the transaction
+            let tx = builder.build(&provider).await.unwrap();
+            provider.send_transaction(tx).await.unwrap();
+
+            // The predicate has spent it's funds
+            let predicate_balance = predicate
+                .get_asset_balance(&provider.base_asset_id())
+                .await
+                .unwrap();
+            assert_eq!(predicate_balance, 0);
         }
     }
+}
+
+mod inputs {
+    use super::*;
 
     mod success {
         use super::*;
@@ -515,7 +718,7 @@ mod inputs {
                 .call()
                 .await
                 .unwrap();
-            assert_eq!(result.value, Input::Contract);
+            assert_eq!(result.value, Some(Input::Contract));
 
             let result = contract_instance
                 .methods()
@@ -523,7 +726,16 @@ mod inputs {
                 .call()
                 .await
                 .unwrap();
-            assert_eq!(result.value, Input::Coin);
+            assert_eq!(result.value, Some(Input::Coin));
+
+            // Assert invalid index returns None
+            let result = contract_instance
+                .methods()
+                .get_input_type(2)
+                .call()
+                .await
+                .unwrap();
+            assert_eq!(result.value, None);
         }
 
         #[tokio::test]
@@ -537,7 +749,17 @@ mod inputs {
                 .await
                 .unwrap();
 
-            assert_eq!(result.value, default_amount);
+            assert_eq!(result.value, Some(default_amount));
+
+            // Assert invalid index returns None
+            let result = contract_instance
+                .methods()
+                .get_input_amount(2)
+                .call()
+                .await
+                .unwrap();
+
+            assert_eq!(result.value, None);
         }
 
         #[tokio::test]
@@ -551,7 +773,17 @@ mod inputs {
                 .await
                 .unwrap();
 
-            assert_eq!(owner_result.value, deployment_wallet.address().into());
+            assert_eq!(owner_result.value, Some(deployment_wallet.address().into()));
+
+            // Assert invalid index returns None
+            let result = contract_instance
+                .methods()
+                .get_input_coin_owner(2)
+                .call()
+                .await
+                .unwrap();
+
+            assert_eq!(result.value, None);
         }
 
         #[tokio::test]
@@ -583,6 +815,116 @@ mod inputs {
                 .take_receipts_checked(None)
                 .unwrap();
             assert_eq!(receipts[1].data(), Some(&[1u8][..]));
+
+            // Assert invalid index returns None
+            let result = contract_instance
+                .methods()
+                .get_input_predicate(3, predicate_bytes.clone())
+                .call()
+                .await
+                .unwrap();
+
+            assert_eq!(result.value, false);
+        }
+
+        #[tokio::test]
+        async fn can_get_input_count_in_tx_upload() {
+            // Prepare wallet and provider
+            let mut wallet = WalletUnlocked::new_random(None);
+            let num_coins = 100;
+            let coins = setup_single_asset_coins(
+                wallet.address(),
+                AssetId::zeroed(),
+                num_coins,
+                DEFAULT_COIN_AMOUNT,
+            );
+            let provider = setup_test_provider(coins, vec![], None, None)
+                .await
+                .unwrap();
+            wallet.set_provider(provider.clone());
+
+            // Prepare bytecode and subsections
+            let bytecode = fs::read(TX_CONTRACT_BYTECODE_PATH).unwrap();
+            let subsection_size = 65536;
+            let subsections = UploadSubsection::split_bytecode(&bytecode, subsection_size).unwrap();
+
+            // Upload each sub section in a separate transaction and include the predicate with the transaction.
+            for subsection in subsections.clone() {
+                let mut builder = UploadTransactionBuilder::prepare_subsection_upload(
+                    subsection,
+                    TxPolicies::default(),
+                );
+
+                // Prepare the predicate
+                let predicate_data = TestTxInputCountPredicateEncoder::default()
+                    .encode_data(builder.inputs().len() as u16 + 1u16) // Add one for this predicate
+                    .unwrap();
+                let predicate: Predicate =
+                    Predicate::load_from(TX_INPUT_COUNT_PREDICATE_BYTECODE_PATH)
+                        .unwrap()
+                        .with_provider(provider.clone())
+                        .with_data(predicate_data);
+                let predicate_coin_amount = 100;
+
+                // Predicate has no funds
+                let predicate_balance = predicate
+                    .get_asset_balance(&provider.base_asset_id())
+                    .await
+                    .unwrap();
+                assert_eq!(predicate_balance, 0);
+                wallet
+                    .transfer(
+                        predicate.address(),
+                        predicate_coin_amount,
+                        *provider.base_asset_id(),
+                        TxPolicies::default(),
+                    )
+                    .await
+                    .unwrap();
+
+                // Predicate has funds
+                let predicate_balance = predicate
+                    .get_asset_balance(&provider.base_asset_id())
+                    .await
+                    .unwrap();
+                assert_eq!(
+                    predicate_balance as usize,
+                    predicate_coin_amount as usize * subsections.len()
+                );
+
+                // Inputs for predicate
+                let predicate_input = predicate
+                    .get_asset_inputs_for_amount(*provider.base_asset_id(), 1, None)
+                    .await
+                    .unwrap();
+
+                // Outputs for predicate
+                let predicate_output = wallet.get_asset_outputs_for_amount(
+                    &wallet.address(),
+                    *provider.base_asset_id(),
+                    1,
+                );
+
+                // Append the predicate to the transaction
+                builder.inputs.push(predicate_input.get(0).unwrap().clone());
+                builder
+                    .outputs
+                    .push(predicate_output.get(0).unwrap().clone());
+
+                wallet.add_witnesses(&mut builder).unwrap();
+                wallet.adjust_for_fee(&mut builder, 0).await.unwrap();
+
+                // Submit the transaction
+                let tx = builder.build(&provider).await.unwrap();
+                provider.send_transaction(tx).await.unwrap();
+
+                // The predicate has spent it's funds
+                let predicate_balance = predicate
+                    .get_asset_balance(&provider.base_asset_id())
+                    .await
+                    .unwrap();
+                assert_eq!(predicate_balance, 0);
+            }
         }
 
         mod message {
@@ -621,7 +963,17 @@ mod inputs {
                     .take_receipts_checked(None)
                     .unwrap();
 
-                assert_eq!(receipts[1].data().unwrap(), *message.sender.hash());
+                assert_eq!(receipts[1].data().unwrap()[8..40], *message.sender.hash());
+
+                // Assert none returned when transaction type is not a message
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_message_sender(0)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -657,7 +1009,17 @@ mod inputs {
                     .take_receipts_checked(None)
                     .unwrap();
 
-                assert_eq!(receipts[1].data().unwrap(), recipient.as_slice());
+                assert_eq!(receipts[1].data().unwrap()[8..40], *recipient.as_slice());
+
+                // Assert none returned when transaction type is not a message
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_message_recipient(0)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -694,7 +1056,17 @@ mod inputs {
                     .take_receipts_checked(None)
                     .unwrap();
 
-                assert_eq!(receipts[1].data().unwrap(), nonce.as_slice());
+                assert_eq!(receipts[1].data().unwrap()[8..40], *nonce.as_slice());
+
+                // Assert none returned when transaction type is not a message
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_message_nonce(0)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -707,7 +1079,17 @@ mod inputs {
                     .await
                     .unwrap();
 
-                assert_eq!(result.value, 0);
+                assert_eq!(result.value, Some(0));
+
+                // Assert none returned when not a valid index
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_witness_index(3)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -742,7 +1124,20 @@ mod inputs {
                     .take_receipts_checked(None)
                     .unwrap();
 
-                assert_eq!(receipts[1].data(), Some(&[0, 0, 0, 0, 0, 0, 0, 3][..]));
+                assert_eq!(
+                    receipts[1].data(),
+                    Some(&[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3][..])
+                );
+
+                // Assert none returned when transaction type is not a message
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_message_data_length(0)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -778,7 +1173,20 @@ mod inputs {
                     .unwrap();
 
                 let len = predicate_bytecode.len() as u64;
-                assert_eq!(receipts[1].data(), Some(len.to_be_bytes().as_slice()));
+                assert_eq!(
+                    receipts[1].data().unwrap()[8..16],
+                    *len.to_be_bytes().as_slice()
+                );
+
+                // Assert none returned when index is invalid
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_predicate_length(3)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -812,7 +1220,20 @@ mod inputs {
                     .take_receipts_checked(None)
                     .unwrap();
 
-                assert_eq!(receipts[1].data(), Some(0u64.to_le_bytes().as_slice()));
+                assert_eq!(
+                    receipts[1].data().unwrap()[8..16],
+                    *0u64.to_le_bytes().as_slice()
+                );
+
+                // Assert none returned when transaction type is not a message
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_predicate_data_length(0)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, None);
             }
 
             #[tokio::test]
@@ -823,7 +1244,7 @@ mod inputs {
 
                 let mut builder = contract_instance
                     .methods()
-                    .get_input_message_data(3, 0, MESSAGE_DATA)
+                    .get_input_message_data(3, 0, Bytes(MESSAGE_DATA.into()))
                     .transaction_builder()
                     .await
                     .unwrap();
@@ -849,6 +1270,92 @@ mod inputs {
                     .unwrap();
 
                 assert_eq!(receipts[1].data(), Some(&[1][..]));
+
+                // Assert none returned when transaction type is not a message
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_message_data(3, 0, Bytes(MESSAGE_DATA.into()))
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, false);
+            }
+
+            #[tokio::test]
+            async fn can_get_input_message_data_with_offset() {
+                let (contract_instance, _, wallet, _) = get_contracts(true).await;
+                let message = &wallet.get_messages().await.unwrap()[0];
+                let provider = wallet.provider().unwrap();
+
+                let mut builder = contract_instance
+                    .methods()
+                    .get_input_message_data(3, 1, Bytes(MESSAGE_DATA[1..].into()))
+                    .transaction_builder()
+                    .await
+                    .unwrap();
+
+                wallet.adjust_for_fee(&mut builder, 1000).await.unwrap();
+
+                builder.inputs_mut().push(SdkInput::ResourceSigned {
+                    resource: CoinType::Message(message.clone()),
+                });
+
+                builder.add_signer(wallet.clone()).unwrap();
+
+                let tx = builder.build(provider).await.unwrap();
+
+                let provider = wallet.provider().unwrap();
+                let tx_id = provider.send_transaction(tx).await.unwrap();
+
+                let receipts = provider
+                    .tx_status(&tx_id)
+                    .await
+                    .unwrap()
+                    .take_receipts_checked(None)
+                    .unwrap();
+
+                assert_eq!(receipts[1].data(), Some(&[1][..]));
+            }
+
+            #[tokio::test]
+            async fn input_message_data_none_when_offset_exceeds_length() {
+                let (contract_instance, _, wallet, _) = get_contracts(true).await;
+                let message = &wallet.get_messages().await.unwrap()[0];
+                let provider = wallet.provider().unwrap();
+
+                let mut builder = contract_instance
+                    .methods()
+                    .get_input_message_data(
+                        3,
+                        (MESSAGE_DATA.len() + 1) as u64,
+                        Bytes(MESSAGE_DATA.into()),
+                    )
+                    .transaction_builder()
+                    .await
+                    .unwrap();
+
+                wallet.adjust_for_fee(&mut builder, 1000).await.unwrap();
+
+                builder.inputs_mut().push(SdkInput::ResourceSigned {
+                    resource: CoinType::Message(message.clone()),
+                });
+
+                builder.add_signer(wallet.clone()).unwrap();
+
+                let tx = builder.build(provider).await.unwrap();
+
+                let provider = wallet.provider().unwrap();
+                let tx_id = provider.send_transaction(tx).await.unwrap();
+
+                let receipts = provider
+                    .tx_status(&tx_id)
+                    .await
+                    .unwrap()
+                    .take_receipts_checked(None)
+                    .unwrap();
+
+                assert_eq!(receipts[1].data(), Some(&[0][..]));
             }
 
             #[tokio::test]
@@ -860,7 +1367,7 @@ mod inputs {
 
                 let handler = contract_instance
                     .methods()
-                    .get_input_predicate(3, predicate_bytecode);
+                    .get_input_predicate(3, predicate_bytecode.clone());
 
                 let mut builder = handler.transaction_builder().await.unwrap();
 
@@ -882,6 +1389,16 @@ mod inputs {
                     .unwrap();
 
                 assert_eq!(receipts[1].data(), Some(1u8.to_le_bytes().as_slice()));
+
+                // Assert none returned when index is invalid
+                let none_result = contract_instance
+                    .methods()
+                    .get_input_predicate(3, predicate_bytecode)
+                    .call()
+                    .await
+                    .unwrap();
+
+                assert_eq!(none_result.value, false);
             }
         }
     }
@@ -902,12 +1419,135 @@ mod outputs {
                 .call()
                 .await
                 .unwrap();
-            assert_eq!(result.value, Output::Contract);
+            assert_eq!(result.value, Some(Output::Contract));
+
+            // Assert invalid index returns None
+            let result = contract_instance
+                .methods()
+                .get_output_type(2)
+                .call()
+                .await
+                .unwrap();
+            assert_eq!(result.value, None);
+        }
+
+        #[tokio::test]
+        async fn can_get_tx_output_type_for_contract_deployment() {
+            // Setup Wallet
+            let mut node_config = NodeConfig::default();
+            node_config.starting_gas_price = 0;
+            let wallet = launch_custom_provider_and_get_wallets(
+                WalletsConfig::new(
+                    Some(1),             /* Single wallet */
+                    Some(1),             /* Single coin (UTXO) */
+                    Some(1_000_000_000), /* Amount per coin */
+                ),
+                Some(node_config),
+                None,
+            )
+            .await
+            .unwrap()
+            .pop()
+            .unwrap();
+            let provider = wallet.try_provider().unwrap();
+
+            // Get the predicate
+            let predicate: Predicate =
+                Predicate::load_from(TX_CONTRACT_CREATION_PREDICATE_BYTECODE_PATH)
+                    .unwrap()
+                    .with_provider(provider.clone());
+            let predicate_coin_amount = 100;
+
+            // Predicate has no funds
+            let predicate_balance = predicate
+                .get_asset_balance(&provider.base_asset_id())
+                .await
+                .unwrap();
+            assert_eq!(predicate_balance, 0);
+
+            // Transfer funds to predicate
+            wallet
+                .transfer(
+                    predicate.address(),
+                    predicate_coin_amount,
+                    *provider.base_asset_id(),
+                    TxPolicies::default(),
+                )
+                .await
+                .unwrap();
+
+            // Predicate has funds
+            let predicate_balance = predicate
+                .get_asset_balance(&provider.base_asset_id())
+                .await
+                .unwrap();
+            assert_eq!(predicate_balance, predicate_coin_amount);
+
+            // Get contract ready for deployment
+            let binary = fs::read(TX_CONTRACT_BYTECODE_PATH).unwrap();
+            let salt = Salt::new([2u8; 32]);
+            let storage_slots = Vec::<StorageSlot>::new();
+            let contract = Contract::regular(binary.clone(), salt, storage_slots.clone());
+
+            // Start building the transaction
+            let tb: CreateTransactionBuilder =
+                CreateTransactionBuilder::prepare_contract_deployment(
+                    binary,
+                    contract.contract_id(),
+                    contract.state_root(),
+                    salt,
+                    storage_slots,
+                    TxPolicies::default(),
+                );
+
+            // Inputs
+            let inputs = predicate
+                .get_asset_inputs_for_amount(*provider.base_asset_id(), predicate_coin_amount, None)
+                .await
+                .unwrap();
+
+            // Outputs
+            let mut outputs = wallet.get_asset_outputs_for_amount(
+                &wallet.address(),
+                *provider.base_asset_id(),
+                predicate_coin_amount,
+            );
+            outputs.push(SdkOutput::contract_created(
+                contract.contract_id(),
+                contract.state_root(),
+            ));
+
+            let mut tb = tb.with_inputs(inputs).with_outputs(outputs);
+
+            wallet.add_witnesses(&mut tb).unwrap();
+            wallet.adjust_for_fee(&mut tb, 1).await.unwrap();
+
+            // Build transaction
+            let tx = tb.build(provider).await.unwrap();
+
+            // Send trandaction
+            provider
+                .send_transaction_and_await_commit(tx)
+                .await
+                .unwrap()
+                .check(None)
+                .unwrap();
+
+            // Verify contract was deployed
+            let instance = TxContractTest::new(contract.contract_id(), wallet.clone());
+            assert!(instance.methods().get_output_type(0).call().await.is_ok());
+
+            // Verify predicate funds transferred
+            let predicate_balance = predicate
+                .get_asset_balance(&AssetId::default())
+                .await
+                .unwrap();
+            assert_eq!(predicate_balance, 0);
         }
 
         #[tokio::test]
         async fn can_get_tx_output_details() {
-            let (wallet, _, predicate, asset_id, _) = setup_output_predicate().await;
+            let (wallet, _, predicate, asset_id, _) = setup_output_predicate(0, SwayOutput::Coin).await;
 
             let balance = predicate.get_asset_balance(&asset_id).await.unwrap();
 
@@ -926,31 +1566,184 @@ mod outputs {
 
             assert!(balance - transfer_amount == new_balance);
         }
-    }
 
-    mod revert {
-        use super::*;
+        #[tokio::test]
+        async fn can_get_amount_for_output_contract() {
+            let (contract_instance, _, _, _) = get_contracts(true).await;
+            let result = contract_instance
+                .methods()
+                .get_tx_output_amount(0)
+                .call()
+                .await
+                .unwrap();
+            assert_eq!(result.value, None);
+        }
 
-        mod contract {
-            use super::*;
+        #[tokio::test]
+        async fn can_get_output_count_in_tx_upload() {
+            // Prepare wallet and provider
+            let mut wallet = WalletUnlocked::new_random(None);
+            let num_coins = 100;
+            let coins = setup_single_asset_coins(
+                wallet.address(),
+                AssetId::zeroed(),
+                num_coins,
+                DEFAULT_COIN_AMOUNT,
+            );
+            let provider = setup_test_provider(coins, vec![], None, None)
+                .await
+                .unwrap();
+            wallet.set_provider(provider.clone());
 
-            #[tokio::test]
-            #[should_panic(expected = "Revert(0)")]
-            async fn fails_to_get_amount_for_output_contract() {
-                let (contract_instance, _, _, _) = get_contracts(true).await;
-                contract_instance
-                    .methods()
-                    .get_tx_output_amount(0)
-                    .call()
+            // Prepare bytecode and subsections
+            let bytecode = fs::read(TX_CONTRACT_BYTECODE_PATH).unwrap();
+            let subsection_size = 65536;
+            let subsections = UploadSubsection::split_bytecode(&bytecode, subsection_size).unwrap();
+
+            // Upload each sub section in a separate transaction and include the predicate with the transaction.
+            for subsection in subsections.clone() {
+                let mut builder = UploadTransactionBuilder::prepare_subsection_upload(
+                    subsection,
+                    TxPolicies::default(),
+                );
+
+                // Prepare the predicate
+                let predicate_data = TestTxOutputCountPredicateEncoder::default()
+                    .encode_data(builder.inputs().len() as u16 + 1u16) // Add one for this predicate
+                    .unwrap();
+                let predicate: Predicate =
+                    Predicate::load_from(TX_OUTPUT_COUNT_PREDICATE_BYTECODE_PATH)
+                        .unwrap()
+                        .with_provider(provider.clone())
+                        .with_data(predicate_data);
+                let predicate_coin_amount = 100;
+
+                // Predicate has no funds
+                let predicate_balance = predicate
+                    .get_asset_balance(&provider.base_asset_id())
+                    .await
+                    .unwrap();
+                assert_eq!(predicate_balance, 0);
+                wallet
+                    .transfer(
+                        predicate.address(),
+                        predicate_coin_amount,
+                        *provider.base_asset_id(),
+                        TxPolicies::default(),
+                    )
+                    .await
+                    .unwrap();
+
+                // Predicate has funds
+                let predicate_balance = predicate
+                    .get_asset_balance(&provider.base_asset_id())
+                    .await
+                    .unwrap();
+                assert_eq!(
+                    predicate_balance as usize,
+                    predicate_coin_amount as usize * subsections.len()
+                );
+
+                // Inputs for predicate
+                let predicate_input = predicate
+                    .get_asset_inputs_for_amount(*provider.base_asset_id(), 1, None)
+                    .await
+                    .unwrap();
+
+                // Outputs for predicate
+                let predicate_output = wallet.get_asset_outputs_for_amount(
+                    &wallet.address(),
+                    *provider.base_asset_id(),
+                    1,
+                );
+
+                // Append the predicate to the transaction
+                builder.inputs.push(predicate_input.get(0).unwrap().clone());
+                builder
+                    .outputs
+                    .push(predicate_output.get(0).unwrap().clone());
+
+                wallet.add_witnesses(&mut builder).unwrap();
+                wallet.adjust_for_fee(&mut builder, 0).await.unwrap();
+
+                // Submit the transaction
+                let tx = builder.build(&provider).await.unwrap();
+                provider.send_transaction(tx).await.unwrap();
+
+                // The predicate has spent it's funds
+                let predicate_balance = predicate
+                    .get_asset_balance(&provider.base_asset_id())
                     .await
                     .unwrap();
+                assert_eq!(predicate_balance, 0);
             }
         }
+    
+        #[tokio::test]
+        async fn can_get_tx_output_change_details() {
+            // Prepare predicate
+            let (wallet, _, predicate, asset_id, _) = setup_output_predicate(2, SwayOutput::Change).await;
+            let provider = wallet.try_provider().unwrap().clone();
+
+            let balance = predicate.get_asset_balance(&asset_id).await.unwrap();
+
+            // Deploy contract
+            let contract_id = Contract::load_from(TX_OUTPUT_CHANGE_CONTRACT_BYTECODE_PATH, LoadConfiguration::default())
+                .unwrap()
+                .deploy(&wallet, TxPolicies::default())
+                .await
+                .unwrap();
+    
+            let instance = TxOutputChangeContract::new(contract_id.clone(), wallet.clone());
+
+            // Send tokens to the contract
+            let _ = wallet
+                .force_transfer_to_contract(&contract_id, 10, asset_id, TxPolicies::default())
+               .await
+               .unwrap();
+
+            // Build transaction
+            let call_handler = instance.methods().send_assets(wallet.clone().address(), asset_id, 10);
+            let mut tb = call_handler.transaction_builder().await.unwrap();
+
+            // Inputs for predicate
+            let transfer_amount = 100;
+            let predicate_input = predicate
+                .get_asset_inputs_for_amount(asset_id, transfer_amount, None)
+                .await
+                .unwrap();
+
+            // Outputs for predicate
+            let predicate_output = wallet.get_asset_outputs_for_amount(
+                &wallet.address(),
+                asset_id,
+                transfer_amount,
+            );
+
+            // Append the inputs and outputs to the transaction
+            tb.inputs.push(predicate_input.get(0).unwrap().clone());
+            tb.outputs.push(predicate_output.get(0).unwrap().clone());
+            tb.outputs.push(SdkOutput::Change{to: wallet.address().into(), amount: 0, asset_id});
+
+            wallet.adjust_for_fee(&mut tb, 0).await.unwrap();
+            tb.add_signer(wallet.clone()).unwrap();
+    
+            let tx = tb.build(provider.clone()).await.unwrap();
+            let _tx_id = provider.send_transaction(tx).await.unwrap();
+
+            // Assert the predicate balance has changed
+            let new_balance = predicate.get_asset_balance(&asset_id).await.unwrap();
+            assert!(balance - transfer_amount == new_balance);
+        }
+    }
+
+    mod revert {
+        use super::*;
 
         #[tokio::test]
         #[should_panic]
         async fn fails_output_predicate_when_incorrect_asset() {
-            let (wallet1, _, predicate, _, asset_id2) = setup_output_predicate().await;
+            let (wallet1, _, predicate, _, asset_id2) = setup_output_predicate(0, SwayOutput::Coin).await;
 
             let transfer_amount = 10;
             predicate
@@ -967,7 +1760,7 @@ mod outputs {
         #[tokio::test]
         #[should_panic]
         async fn fails_output_predicate_when_incorrect_to() {
-            let (_, wallet2, predicate, asset_id1, _) = setup_output_predicate().await;
+            let (_, wallet2, predicate, asset_id1, _) = setup_output_predicate(0, SwayOutput::Coin).await;
 
             let transfer_amount = 10;
             predicate
diff --git a/test/src/sdk-harness/test_projects/vec_in_abi/mod.rs b/test/src/sdk-harness/test_projects/vec_in_abi/mod.rs
index 716be40aba8..c4a711ff5de 100644
--- a/test/src/sdk-harness/test_projects/vec_in_abi/mod.rs
+++ b/test/src/sdk-harness/test_projects/vec_in_abi/mod.rs
@@ -1,4 +1,6 @@
-use fuels::{accounts::wallet::WalletUnlocked, prelude::*, types::Bits256};
+use fuels::{
+    accounts::wallet::WalletUnlocked, prelude::*, programs::calls::ContractCall, types::Bits256,
+};
 use std::str::FromStr;
 
 abigen!(Contract(
@@ -211,3 +213,32 @@ async fn test_vec_in_vec() -> Result<()> {
 
     Ok(())
 }
+
+async fn test_echo<T>(
+    f: impl Fn(T) -> CallHandler<fuels::accounts::wallet::WalletUnlocked, ContractCall, T>,
+    input: T,
+) where
+    T: Eq
+        + Clone
+        + fuels::core::traits::Tokenizable
+        + fuels::core::traits::Parameterize
+        + std::fmt::Debug,
+{
+    let response = (f)(input.clone()).call().await.unwrap();
+    assert_eq!(input, response.value);
+}
+
+#[tokio::test]
+async fn test_echos() {
+    let (instance, _id) = get_vec_in_abi_instance().await;
+    let contract_methods = instance.methods();
+
+    test_echo(|v| contract_methods.echo_u8(v), vec![0u8, 1u8, 2u8]).await;
+    test_echo(|v| contract_methods.echo_u16(v), vec![0u16, 1u16, 2u16]).await;
+    test_echo(|v| contract_methods.echo_u32(v), vec![0u32, 1u32, 2u32]).await;
+    test_echo(
+        |v| contract_methods.echo_u32_vec_in_vec(v),
+        vec![vec![0u32], vec![1u32], vec![2u32]],
+    )
+    .await;
+}
diff --git a/test/src/sdk-harness/test_projects/vec_in_abi/src/main.sw b/test/src/sdk-harness/test_projects/vec_in_abi/src/main.sw
index 1af6cd06bfe..40d3443b71f 100644
--- a/test/src/sdk-harness/test_projects/vec_in_abi/src/main.sw
+++ b/test/src/sdk-harness/test_projects/vec_in_abi/src/main.sw
@@ -26,6 +26,11 @@ abi MyContract {
     fn array_test(input: Vec<[Address; 2]>) -> [[Address; 2]; 3];
     fn string_test(input: Vec<str[4]>) -> [str[4]; 3];
     fn vec_in_vec_test(input: Vec<Vec<u64>>) -> [u64; 9];
+
+    fn echo_u8(input: Vec<u8>) -> Vec<u8>;
+    fn echo_u16(input: Vec<u16>) -> Vec<u16>;
+    fn echo_u32(input: Vec<u32>) -> Vec<u32>;
+    fn echo_u32_vec_in_vec(input: Vec<Vec<u32>>) -> Vec<Vec<u32>>;
 }
 
 impl MyContract for Contract {
@@ -82,4 +87,20 @@ impl MyContract for Contract {
         let (v20, v21, v22) = (v2.get(0).unwrap(), v2.get(1).unwrap(), v2.get(2).unwrap());
         [v00, v01, v02, v10, v11, v12, v20, v21, v22]
     }
+
+    fn echo_u8(input: Vec<u8>) -> Vec<u8> {
+        input
+    }
+
+    fn echo_u16(input: Vec<u16>) -> Vec<u16> {
+        input
+    }
+
+    fn echo_u32(input: Vec<u32>) -> Vec<u32> {
+        input
+    }
+
+    fn echo_u32_vec_in_vec(input: Vec<Vec<u32>>) -> Vec<Vec<u32>> {
+        input
+    }
 }
diff --git a/test/tests/tests.rs b/test/tests/tests.rs
new file mode 100644
index 00000000000..626864f2e74
--- /dev/null
+++ b/test/tests/tests.rs
@@ -0,0 +1,174 @@
+use libtest_mimic::{Arguments, Trial};
+use normalize_path::NormalizePath;
+use regex::Regex;
+use std::{path::PathBuf, str::FromStr, sync::Once};
+
+static FORC_COMPILATION: Once = Once::new();
+
+fn compile_forc() {
+    let args = vec!["b", "--release", "-p", "forc"];
+    let o = std::process::Command::new("cargo")
+        .args(args)
+        .output()
+        .unwrap();
+    assert!(o.status.success());
+}
+
+pub fn main() {
+    let repo_root: PathBuf =
+        PathBuf::from_str(&std::env::var("CARGO_MANIFEST_DIR").unwrap()).unwrap();
+    let repo_root = repo_root.parent().unwrap().to_path_buf();
+
+    let mut args = Arguments::from_args();
+    args.nocapture = true;
+
+    let tests = discover_test()
+        .into_iter()
+        .map(|dir| {
+            let test_programs_dir = "src/e2e_vm_tests/test_programs/";
+            let name = dir
+                .to_str()
+                .unwrap()
+                .to_string()
+                .replace(test_programs_dir, "");
+
+            let repo_root = repo_root.clone();
+            Trial::test(name, move || {
+                FORC_COMPILATION.call_once(|| {
+                    compile_forc();
+                });
+
+                let snapshot_toml =
+                    std::fs::read_to_string(format!("{}/snapshot.toml", dir.display()))?;
+                let snapshot_toml = toml::from_str::<toml::Value>(&snapshot_toml)?;
+                let cmds = if let Some(cmds) = snapshot_toml.get("cmds") {
+                    cmds.as_array()
+                        .unwrap()
+                        .iter()
+                        .map(|v| v.as_str().unwrap())
+                        .collect::<Vec<_>>()
+                } else {
+                    vec!["forc build --path {root}"]
+                };
+
+                let root = format!("test/{}", dir.display());
+
+                use std::fmt::Write;
+                let mut snapshot = String::new();
+
+                for cmd in cmds {
+                    let cmd = cmd.replace("{root}", &root);
+
+                    let _ = writeln!(&mut snapshot, "> {}", cmd);
+
+                    let cmd = if let Some(cmd) = cmd.strip_prefix("forc ") {
+                        format!("target/release/forc {cmd} 1>&2")
+                    } else {
+                        panic!("Not supported. Possible commands: forc")
+                    };
+
+                    let o = duct::cmd!("bash", "-c", cmd.clone())
+                        .dir(repo_root.clone())
+                        .stderr_to_stdout()
+                        .stdout_capture()
+                        .unchecked()
+                        .start()
+                        .unwrap();
+                    let o = o.wait().unwrap();
+
+                    let _ = writeln!(
+                        &mut snapshot,
+                        "{}",
+                        clean_output(&format!(
+                            "exit status: {}\noutput:\n{}",
+                            o.status.code().unwrap(),
+                            std::str::from_utf8(&o.stdout).unwrap(),
+                        ))
+                    );
+                }
+
+                fn stdout(root: &str, snapshot: &str) {
+                    let root = PathBuf::from_str(root).unwrap();
+                    let root = root.normalize();
+
+                    let mut insta = insta::Settings::new();
+                    insta.set_snapshot_path(root);
+                    insta.set_prepend_module_to_snapshot(false);
+                    insta.set_omit_expression(true);
+                    let scope = insta.bind_to_scope();
+                    insta::assert_snapshot!("stdout", snapshot);
+                    drop(scope);
+                }
+                stdout(&format!("{}/{root}", repo_root.display()), &snapshot);
+
+                Ok(())
+            })
+        })
+        .collect();
+    libtest_mimic::run(&args, tests).exit();
+}
+
+pub fn discover_test() -> Vec<PathBuf> {
+    use glob::glob;
+
+    let mut entries = vec![];
+
+    for entry in glob("**/snapshot.toml")
+        .expect("Failed to read glob pattern")
+        .flatten()
+    {
+        entries.push(entry.parent().unwrap().to_owned())
+    }
+
+    entries
+}
+
+fn clean_output(output: &str) -> String {
+    #[derive(Default)]
+    struct RawText(String);
+
+    impl vte::Perform for RawText {
+        fn print(&mut self, c: char) {
+            self.0.push(c);
+        }
+
+        fn execute(&mut self, _: u8) {}
+
+        fn hook(&mut self, _: &vte::Params, _: &[u8], _: bool, _: char) {}
+
+        fn put(&mut self, b: u8) {
+            self.0.push(b as char);
+        }
+
+        fn unhook(&mut self) {}
+
+        fn osc_dispatch(&mut self, _: &[&[u8]], _: bool) {}
+
+        fn csi_dispatch(&mut self, _: &vte::Params, _: &[u8], _: bool, _: char) {}
+
+        fn esc_dispatch(&mut self, _: &[u8], _: bool, _: u8) {}
+    }
+
+    let mut raw = String::new();
+    for line in output.lines() {
+        let mut performer = RawText::default();
+        let mut p = vte::Parser::new();
+        for b in line.as_bytes() {
+            p.advance(&mut performer, *b);
+        }
+        raw.push_str(&performer.0);
+        raw.push('\n');
+    }
+
+    // Remove absolute paths from snapshot tests
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    let manifest_dir: PathBuf = PathBuf::from(manifest_dir);
+    let parent = manifest_dir.parent().unwrap();
+    let result = raw.replace(&format!("{}/", parent.display()), "");
+
+    // Remove compilation time
+    let r = Regex::new("(Finished release \\[.*?\\] target\\(s\\) \\[.*?\\] in )(.*?s)").unwrap();
+    let result = r.replace(&result, "$1???");
+
+    result.to_string()
+}
diff --git a/test/update-contract-ids.sh b/test/update-contract-ids.sh
new file mode 100755
index 00000000000..591a2a7052d
--- /dev/null
+++ b/test/update-contract-ids.sh
@@ -0,0 +1,100 @@
+#! /bin/bash
+
+print_help() {
+    echo "
+ -i          run interactively
+";
+}
+
+INTERACTIVELY="0"
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        -i) INTERACTIVELY="1"; shift ;;
+        *) print_help; exit 1 ;;
+    esac
+    shift
+done
+
+
+CHANGES=$(git status --porcelain | wc -l)
+
+BOLD_RED='\033[1;31m'
+BOLD_GREEN="\033[1;32m"
+BOLD_YELLOW='\033[1;33m'
+BOLD_WHITE='\033[1;97m'
+NC='\033[0m'
+
+function join_by {
+  local d=${1-} f=${2-}
+  if shift 2; then
+    printf %s "$f" "${@/#/$d}"
+  fi
+}
+
+ask_confirmation() {
+    echo -e "${BOLD_WHITE}Command below needs confirmation before running.${NC} $2"
+    echo "> $1"
+    read -p "Run the command above? (y/n) " -n 1 -r </dev/tty
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]
+    then
+        bash -c "$1"
+    else
+        exit 1
+    fi
+}
+
+grep --include \*.sw -Hno "// AUTO-CONTRACT-ID" . -R | while read line ; do
+    PARTS=($(echo $line | sed 's/:/ /g'))
+    FOLDER=$(dirname ${PARTS[0]})
+    FILE=${PARTS[0]}
+    LINE=${PARTS[1]}
+
+    SED_COMMAND="${LINE}"'!d'
+    CONTRACT_ARGS=($(sed "$SED_COMMAND" $FILE))
+    CONTRACT_ARGS=$(join_by " " ${CONTRACT_ARGS[@]:6})
+
+    if [[ $CONTRACT_ARGS ]]; then 
+        PROJ=$(realpath "$FOLDER/..")
+        echo -e "${BOLD_WHITE}$PROJ${NC}"
+
+        pushd "$FOLDER/.." >> /dev/null
+        CONTRACT_ID=$(cargo r -p forc --release -- contract-id --path $CONTRACT_ARGS 2> /dev/null | grep -oP '0x[a-zA-Z0-9]{64}')
+
+        if [[ $CONTRACT_ID ]]; then 
+            popd >> /dev/null
+
+            SED_EXPR="${LINE}s/0x[a-zA-Z0-9]*/$CONTRACT_ID/g"
+
+            # check if there is a diff
+            diff -s --color <(cat $FILE) <(cat $FILE | sed --expression="$SED_EXPR") > /dev/null
+            if [ $? -eq 0 ]; then
+              # no diff, continue
+              echo -e "    ${BOLD_GREEN}no changes needed${NC} ($CONTRACT_ID)"
+            else 
+              # diff detected, check we are clean to update files, if not abort
+              if [[ "$INTERACTIVELY" == "0" ]]; then
+                # Don´t change anything if git is dirty
+                if [ "$CHANGES" != "0" ]; then
+                  echo -e "    ${BOLD_RED}Aborting${NC} This contract id needs update, but git state is not clean. commit, restore first or run with \"-i\"."
+                  echo $FILE
+                  diff -s --color <(cat $FILE) <(cat $FILE | sed --expression="$SED_EXPR")
+                  exit
+                fi
+                # we are clean and can update files
+                sed -i "$SED_EXPR" $FILE
+              else
+                # ask confirmation before applying the change
+                diff -s --color <(cat $FILE) <(cat $FILE | sed --expression="$SED_EXPR")
+                ask_confirmation "sed -i \"$SED_EXPR\" $FILE" "Update contract id"
+              fi
+              echo -e "    ${BOLD_GREEN}updated${NC} ($CONTRACT_ID)"
+            fi
+        else
+            echo -e "    ${BOLD_RED}error${NC}"
+            cargo r -p forc --release -- contract-id --release
+            popd >> /dev/null
+        fi
+    fi
+done